Se o seu webhook no Make não dispara a automação ou retorna erros como 400 Bad Request, 500 Internal Server Error ou timeout, você não está sozinho. Os erros mais comuns ao configurar webhooks no Make geralmente vêm de payloads mal formatados, cabeçalhos ausentes, problemas de autenticação ou endpoints mal configurados. Este guia resolve os 15 erros que mais travam iniciantes, com soluções práticas e ferramentas gratuitas para testar antes de colocar a mão na massa.

Você vai aprender a testar webhooks antes de conectá-los ao Make usando webhook.site, Postman e ngrok, além de como estruturar payloads e cabeçalhos corretamente para evitar erros 400. Também mostro como resolver timeout, problemas de segurança (401/403) e casos em que o app de origem não tem integração nativa com o Make. Tudo com exemplos reais e comandos que você pode copiar e colar.

O que são webhooks e por que são essenciais no Make

Webhooks são como campainhas digitais: ao invés de você ficar perguntando "tem recado?" a cada 5 minutos (API tradicional), o aplicativo te avisa na hora quando algo novo acontece. No Make, os webhooks permitem receber dados em tempo real de apps que não têm integração nativa, como sistemas personalizados ou lojas virtuais que só enviam notificações via webhook.

O Make (ex-Integromat) é uma ferramenta low-code que usa webhooks como um dos principais gatilhos para automações. Enquanto APIs tradicionais exigem polling (verificar repetidamente por mudanças), webhooks fazem o inverso: o servidor envia os dados quando há um evento, economizando requisições e recursos. Para entender melhor como o Make funciona como plataforma, confira o guia Make (ex-Integromat): o que é e como usar.

Curiosidade técnica: O Make usa webhooks assíncronos com um buffer de 30 segundos por padrão. Se o servidor de origem não responder dentro desse tempo, o Make considera a requisição como falha e tenta novamente com política de retry configurável.

Os 15 erros mais comuns ao configurar webhooks no Make (e como identificá-los)

Aqui estão os erros que mais aparecem na tela de iniciantes — categorizados por tipo e com impacto direto na automação. Use a tabela para identificar rapidamente o seu problema e ir direto à solução.

Código de erro Erro / Sintoma Causa provável Solução inicial
Sem erro (silencioso) Webhook não dispara nenhuma ação no Make URL do webhook incorreta ou endpoint não configurado para receber POST Verifique se a URL no Make termina com /webhook/NOME_DO_MODULO e se o app de origem envia para o endpoint correto
404 Not Found O Make retorna "Endpoint não encontrado" ao testar o webhook URL do webhook foi deletada ou o módulo foi desativado no Make Reative o módulo no Make ou gere uma nova URL de webhook
405 Method Not Allowed O servidor de origem rejeita a requisição com "Método não permitido" O app envia GET, mas o Make espera POST (ou vice-versa) Configure o método correto no Make (geralmente POST) e no app de origem
Sem resposta O Make recebe a requisição, mas não processa os dados Payload vazio ou campo de dados não compatível com o módulo seguinte Adicione um filtro no Make para validar o campo esperado antes de prosseguir
Timeout A automação trava após X segundos sem resposta Payload muito grande ou servidor lento na origem Reduza o payload ou aumente o timeout na API de origem (ex: de 5s para 30s)
400 Bad Request O Make rejeita o webhook com "Corpo da requisição inválido" JSON mal formatado, campo obrigatório ausente ou Content-Type incorreto Valide o JSON com um validador online e adicione Content-Type: application/json no cabeçalho
JSON Parse Error O Make não consegue ler o payload enviado String JSON com aspas duplas ou caracteres especiais não escapados Use JSON.stringify() no código que envia o webhook ou valide com JSONLint
Campo ausente A automação para porque um campo esperado não chegou O app de origem não envia todos os campos obrigatórios Adicione um módulo "Parse JSON" antes para mapear os campos e use filtros para ignorar requisições incompletas
500 Internal Server Error O Make retorna erro genérico ao processar o webhook Erro no módulo seguinte da automação (ex: planilha cheia, API com limite atingido) Verifique os logs do Make (aba "History") e isole o módulo problemático para debugar
429 Too Many Requests O Make ou a API de origem bloqueia requisições por excesso O app envia webhooks em loop ou o Make tem política de rate limiting Ajuste a frequência de envios ou implemente um debounce na origem
401 Unauthorized O Make rejeita o webhook por falta de autenticação Token ou assinatura HMAC ausente ou inválida Adicione cabeçalho Authorization: Bearer SEU_TOKEN ou configure HMAC no campo "Secret" do webhook
403 Forbidden O servidor de origem bloqueia o Make com "Acesso negado" IP não whitelistado ou domínio não autorizado Adicione o IP do Make (consulte na aba "History") à lista branca do app de origem
CORS Blocked O navegador bloqueia a requisição por política de CORS O webhook é testado localmente sem proxy (ex: ngrok) Use ngrok para expor o endpoint local com HTTPS e adicione CORS no servidor
Payload muito grande A automação falha com "Requisição excede limite" O app envia mais de 10MB de dados ou centenas de registros Divida os dados em batches ou use o módulo "Split" no Make para processar em partes
Webhook não dispara O Make não recebe dados mesmo com URL correta O app de origem usa HTTPS mas o Make só aceita HTTP (ou vice-versa) Force HTTPS na URL do Make ou configure o app para enviar para http:// (não recomendado para produção)

Como testar seu webhook antes de conectá-lo ao Make (ferramentas gratuitas)

Antes de sair configurando webhooks no Make, teste se o endpoint recebe os dados corretamente usando essas ferramentas gratuitas. Assim você isola problemas de rede, payload ou cabeçalhos antes de integrar com a automação.

1. webhook.site — Teste instantâneo sem instalação

  1. Acesse webhook.site e copie a URL única gerada (ex: https://webhook.site/12345678-abcd-efgh-5678-90abcdef1234).
  2. No app que envia o webhook (ex: loja virtual, CRM), cole essa URL como endpoint.
  3. Envie um teste e confira na aba "Requests" da página se os dados chegaram. Exemplo de resposta bem-sucedida: 
    {
  "time": "2024-05-20T14:30:00Z",
  "headers": { "Content-Type": "application/json" },
  "body": {
    "order_id": "12345",
    "status": "paid"
  }
}
  4. Se não chegar, reveja o método HTTP (deve ser POST) e o Content-Type no cabeçalho.

Dica: Copie o ID do request no webhook.site e cole no Google para encontrar tutoriais específicos do erro que aparecer.

2. Postman — Teste avançado com autenticação e validação

  1. Baixe o Postman e crie uma nova requisição.
  2. Configure:
    • Method: POST
    • URL: Cole a URL do seu webhook no Make (ex: https://hook.make.com/abc123)
    • Headers: Adicione Content-Type: application/json e Authorization: Bearer SEU_TOKEN (se necessário)
    • Body: Selecione "raw" e "JSON", cole um payload válido: 
      {
  "event": "order_paid",
  "data": {
    "order_id": "67890",
    "customer_email": "cliente@exemplo.com"
  }
}
  3. Clique em Send e confira o status 200 e o body de resposta.
  4. Se der erro 400, valide o JSON com o botão "Prettify" no Postman.

3. ngrok — Teste webhooks locais ou sem HTTPS

Se você desenvolve um app local (ex: Python, Node.js) que precisa enviar webhooks para o Make, use o ngrok para expor sua máquina na internet.

  1. Baixe e instale o ngrok. Execute no terminal: 
    ngrok http 3000
    (substitua 3000 pela porta do seu servidor local).
  2. Copie a URL HTTPS gerada (ex: https://abc123.ngrok.io/webhook) e cole no app de origem.
  3. No Make, crie um webhook com essa URL. Quando o app local enviar dados, eles chegarão no Make.
  4. Se der erro CORS, adicione no seu servidor local: 
    res.setHeader('Access-Control-Allow-Origin', '*');
    (em Node.js) ou 
    header("Access-Control-Allow-Origin: *");
    (em PHP).

Para aprender a usar o Make gratuitamente com esses testes, confira o guia Como automatizar com Make de graça.

Configuração correta de payloads e cabeçalhos no Make para evitar erros 400

Um erro 400 Bad Request no Make quase sempre significa que o payload ou os cabeçalhos estão mal configurados. Aqui você aprende a estruturar tudo corretamente e evita 90% desses erros.

Estrutura mínima de um payload válido

O Make espera um JSON com uma estrutura clara. Exemplo mínimo:

{
  "data": {
    "order_id": 12345,
    "status": "paid",
    "customer": {
      "email": "cliente@exemplo.com",
      "name": "João Silva"
    }
  }
}

Campos obrigatórios: data (ou outro nome que você mapeie no módulo "Parse JSON" do Make). Se o app de origem não envia data, adicione um módulo "Parse JSON" no Make para renomear os campos.

Cabeçalhos essenciais

Sem os cabeçalhos corretos, o servidor rejeita a requisição mesmo com JSON válido. Sempre inclua:

Cabeçalho Valor Exemplo
Content-Type application/json Content-Type: application/json
Authorization (opcional) Bearer TOKEN ou HMAC assinatura Authorization: Bearer abc123xyz
User-Agent (opcional) Identifique a origem (ex: "MinhaLoja/1.0") User-Agent: MinhaLoja/1.0

Payload mal formatado vs. correto

Problema Exemplo ruim Solução
Falta Content-Type Envia texto puro ou form-data sem cabeçalho Adicione Content-Type: application/json e envie JSON puro
JSON com aspas simples { 'order_id': 123 } Use aspas duplas: { "order_id": 123 }
Campo com nome diferente do esperado { "id": 123 } mas o Make espera "order_id" Use módulo "Parse JSON" para mapear ou renomeie no app de origem
JSON com nulos ou undefined { "email": null } Remova campos obrigatórios ou use "email": "" (string vazia)

Para quem considera alternativas ao Make, confira Make vs. Zapier: qual escolher para webhooks?

Curiosidade técnica: O Make usa o JSON Schema internamente para validar payloads. Se o seu JSON não seguir o schema esperado (ex: campo obrigatório ausente), o Make rejeita mesmo que o JSON seja válido no validador online.

Resolvendo timeout e latência em webhooks no Make: passo a passo técnico

Webhooks com timeout ou latência alta travam automações. As causas mais comuns são payloads grandes, servidores lentos na origem ou falta de keep-alive. Aqui estão as soluções técnicas para cada caso.

1. Otimize o payload

Payloads acima de 1MB já podem causar lentidão. Reduza o tamanho:

  • Envie apenas campos essenciais (ex: só o order_id ao invés de todo o carrinho)
  • Use compressão GZIP no servidor de origem (se o Make suportar)
  • Divida dados grandes em batches com o módulo "Split" no Make

2. Aumente o timeout na API de origem

Muitas APIs têm timeout padrão de 5-10 segundos. Aumente para 30s ou mais:

curl -X POST -H "Content-Type: application/json" \
--max-time 30 \
-d '{"order_id":12345}' \
https://hook.make.com/abc123

(Adapte o parâmetro --max-time para seu cliente HTTP)

3. Use webhooks assíncronos (Make Modules)

Para operações longas, use o módulo "Make a HTTP Request" ao invés do Webhook trigger. Isso permite processar em segundo plano sem timeout.

Curiosidade técnica: O Make usa conexões HTTP/2 internamente, mas muitos servidores de origem ainda usam HTTP/1.1. A falta de multiplexação pode causar latência em payloads grandes.

Segurança em webhooks: como evitar erros 403 e 401 no Make

Erros 401 Unauthorized e 403 Forbidden geralmente vêm de autenticação mal configurada. Proteja seus webhooks com tokens, assinaturas HMAC e whitelisting de IPs.

1. Autenticação via Bearer Token

Adicione um token no cabeçalho Authorization:

Authorization: Bearer SEU_TOKEN_SECRETO

No Make, configure no campo "Headers" do módulo Webhook.

2. Assinatura HMAC para verificação

O Make permite validar a origem com HMAC. No app de origem, calcule:

HMAC-SHA256(SEU_SEGREDO, payload)

Envie no cabeçalho X-Signature. No Make, cole o segredo no campo "Secret" do webhook.

3. Whitelisting de IPs

Restrinja o acesso ao seu servidor apenas para os IPs do Make. Consulte os IPs atuais na documentação oficial.

Aviso crítico: Nunca armazene tokens ou segredos diretamente no código. Use variáveis de ambiente ou o gerenciador de segredos do Make.

Webhooks no Make com apps sem integração nativa: soluções práticas

Se o app não tem integração direta com o Make, use essas técnicas para criar pontes via webhook:

1. Webhook + HTTP Request Module

  1. Crie um Webhook trigger no Make
  2. Adicione um módulo "Make a HTTP Request" para chamar a API do app
  3. Mapeie os dados do webhook para os parâmetros da API

2. Google Apps Script como intermediário

Para apps que só aceitam webhooks do Google, crie um script que:

  1. Recebe o webhook do Make
  2. Chama a API do app via UrlFetchApp
  3. Retorna status para o Make

3. n8n para transformação complexa

Para casos avançados, use o n8n como intermediário. Exemplo: transformar XML em JSON antes de enviar ao Make.

Exemplo prático: Automação Make -> Google Sheets via webhook:

  1. Crie um webhook no Make com URL do Google Apps Script
  2. No script, use SpreadsheetApp.openById() para escrever os dados
  3. Retorne { success: true } para o Make

Documentação oficial e recursos avançados para webhooks no Make

Para casos complexos, use os recursos avançados do Make e consulte a documentação oficial.

Recursos avançados

  • Webhook History: Veja todos os payloads recebidos e status de processamento
  • Retry Policy: Configure até 10 tentativas com intervalo exponencial
  • Error Handling: Use rotas alternativas com o módulo "Error Handler"

Para automações empresariais, considere alternativas como o Power Automate ou o n8n para maior controle sobre webhooks.

Dica final: Teste sempre com payloads reais antes de colocar em produção. Use o modo "Debug" no Make para inspecionar cada etapa da automação.

Perguntas frequentes sobre erros comuns ao configurar webhooks no Make e como corrigi-los

Por que meu webhook no Make não está recebendo dados?

Verifique se a URL do webhook no Make está correta e termina com /webhook/NOME_DO_MODULO. Confirme também se o app de origem está enviando para o endpoint exato e usando o método HTTP correto (geralmente POST).

Como testar se um webhook está funcionando antes de conectá-lo ao Make?

Use ferramentas gratuitas como webhook.site para receber dados instantaneamente, Postman para testes avançados com autenticação ou ngrok para expor endpoints locais. Esses testes isolam problemas de rede e payload antes da integração.

O que fazer se o Make retornar erro 400 ao enviar webhook?

O erro 400 geralmente indica JSON mal formatado ou cabeçalhos ausentes. Valide seu payload com Content-Type: application/json e use ferramentas como JSONLint para corrigir estruturas inválidas. Verifique também campos obrigatórios no schema do Make.

Como resolver timeout ao configurar webhook no Make?

Timeouts ocorrem por payloads grandes ou servidores lentos. Reduza o tamanho dos dados, aumente o timeout na API de origem (ex: de 5s para 30s) ou use módulos assíncronos no Make para processamento em segundo plano.

Qual a diferença entre webhook e API no Make?

APIs tradicionais exigem polling (verificar repetidamente por mudanças), enquanto webhooks recebem dados em tempo real quando um evento ocorre. No Make, webhooks são gatilhos que iniciam automações automaticamente, economizando recursos.

Como usar webhooks no Make com aplicativos sem integração nativa?

Use técnicas como Webhook trigger + HTTP Request module, Google Apps Script como intermediário ou n8n para transformação de dados. Para apps que só aceitam webhooks do Google, crie um script que recebe do Make e chama a API do app.

O Make tem limite de requisições por webhook?

O Make não impõe limites fixos, mas políticas de rate limiting podem ser aplicadas pela API de origem. Erros 429 indicam excesso de requisições; ajuste a frequência ou implemente um debounce na origem para evitar bloqueios.

Como debugar webhooks no Make usando ferramentas gratuitas?

Use a aba History no Make para inspecionar payloads e erros. Para testes avançados, utilize Postman com autenticação ou ngrok para simular endpoints locais. O webhook.site é ideal para validação imediata sem configuração.

🔧 Webhooks no Make: erros resolvidos, automações funcionando!

Configurar webhooks no Make pode parecer complicado no início, mas com as soluções práticas deste guia — desde testes com ferramentas gratuitas até a estruturação correta de payloads e cabeçalhos — você evita os 15 erros mais comuns que travam iniciantes. Agora você já sabe como identificar códigos de erro como 400, 401, 403 ou timeout, e tem técnicas para resolver cada um deles. Lembre-se: testar antes de conectar ao Make é a chave para automações estáveis e sem surpresas.

  • Teste sempre com webhook.site, Postman ou ngrok antes de integrar ao Make
  • Valide payloads com JSON Schema e adicione cabeçalhos como Content-Type: application/json
  • Proteja seus webhooks com tokens, HMAC e whitelisting de IPs
  • Otimize payloads para evitar timeouts e erros de requisição grande
  • Use recursos avançados como retry policy e webhook history para debugar

Pronto para colocar suas automações para funcionar? Explore nossa categoria de tutoriais Make para aprender mais sobre integrações poderosas e comece a automatizar hoje mesmo!

Quer mais sobre o assunto? Veja todos os artigos de Make & Zapier ou a lista completa de artigos.