Operações

Pare de pagar o Zapier

Você precisa de alguns fluxos confiáveis, não de 7.000 conectores.

O Zapier custa US$30–69 / mês, ou seja, US$360–828 por ano. Você tem dois caminhos:

Opção 1 · Instalar

Instale o n8n grátis

O n8n é a casa de máquinas do seu negócio. Você desenha uma cadeia de etapas numa tela (quando um formulário é enviado, criar o registro no CRM, avisar no Slack, mandar o email de boas-vindas) e ela roda sem você, dia e noite. Mais de 400 serviços já vêm conectados e, quando nenhum serve, você chama qualquer API. A diferença para o Zapier e o Make: você pode rodá-lo na sua própria máquina. Onde o Zapier conta suas tarefas e cobra cada gatilho, o seu servidor não conta nada. E para as automações que chamam o Claude, você coloca a sua própria chave em vez de comprar os créditos de IA deles.

n8n vs Zapier / Make

Critérion8nZapier / Make
PreçoUS$0, você só paga o seu servidorDe €9 a €26/mês, e depois mais
VolumeIlimitado, é a sua máquina750 tarefas por mês no Zapier Pro
Os seus dadosNunca saem do seu servidorPassam por eles a cada etapa
Código próprioUm nó de JavaScript ou Python quando o visual não dá contaRestrito, e reservado a planos mais altos
A IA por dentroA sua própria chave do Claude, a preço de custoCréditos de IA cobrados à parte

Como instalar (mesmo começando do zero)

Há dois caminhos: na sua máquina para experimentar, ou num servidor para que as suas automações continuem rodando com o computador desligado. Comece pelo primeiro.

  1. 1

    Instale o Docker Desktop

    Baixe em docker.com, instale e abra uma vez. É o motor que vai rodar o n8n na sua máquina.

  2. 2

    Cole este prompt no Claude (Code ou Desktop)

    Ele instala o n8n a partir do repositório oficial, inicia e confere se a interface responde:

    Instale o n8n na minha máquina (a ferramenta open source de automação de workflows, repositório do GitHub n8n-io/n8n) com Docker, seguindo a documentação oficial docs.n8n.io. Crie a pasta de trabalho, escreva o docker-compose.yml com um volume que preserve os meus workflows entre reinicializações, suba o serviço e verifique se a interface responde em http://localhost:5678. Depois me explique como criar o meu primeiro workflow. Explique cada etapa de forma simples, sou iniciante.
    
    Revise o repositório do GitHub e verifique se é seguro instalá-lo, considerando a minha máquina e a minha infraestrutura. Faça-me o máximo de perguntas possível, usando widgets, para esclarecer o meu pedido e ser o mais preciso que puder.
  3. 3

    Monte a sua primeira cadeia

    Abra http://localhost:5678, crie a sua conta e comece por um caso simples e útil: um formulário enviado que dispara um email. Quando isso funcionar, o resto vem naturalmente.

  4. 4

    Quando ficar sério, leve para um servidor

    Na sua máquina, as suas automações param quando você fecha o notebook. Peça ao Claude para implantá-lo num servidor ou plataforma de hospedagem, com um domínio de verdade, no dia em que você realmente depender disso.

Para que você vai usar

A tarefa repetitiva que você faz na mão

Copiar um formulário para uma planilha, cobrar um orçamento sem resposta, arquivar anexos: você monta uma vez e roda para sempre. É aí que o tempo volta.

O Claude ligado às suas ferramentas de verdade

Chega um email, o Claude lê, classifica, redige a resposta e salva. O n8n é o cano que liga a inteligência às suas ferramentas do dia a dia, com a sua própria chave de API.

A entrega que você deixa montada para um cliente

Você instala o n8n na empresa dele, monta as automações, e a equipe consegue ler e manter tudo porque é visual. Você cobra o trabalho, não uma assinatura que segue rodando.

Saúde do projeto

estrelas no GitHub
206.811
Forks
61k
Contribuidores
429
Commits
25.4k
Idade do projeto
7,3 anos
Licença
Other

Feito com: TypeScript 92.2% · Vue 6.3% · JavaScript 0.7%

Dados públicos do repositório no GitHub, coletados em 8 de outubro de 2026.

Opção 2 · Construir

Crie o seu próprio Zapier

Para quem é

Esta construção é para uma equipe de operações que roda um conjunto conhecido de automações disparadas por webhooks. O objetivo: receber eventos, transformar dados e executar uma sequência curta de ações confiáveis. Se você precisa de mais do que isso, continue pagando: construir por conta própria serve para ter uma ferramenta sob medida para o seu jeito de trabalhar, não para refazer o plano de uma empresa com milhões de investimento.

Mesma construção, outro logo: esta v1 também substitui n8n e Pipedream, porque os três resolvem o mesmo trabalho central.

O que o prompt constrói e o que fica de fora

O prompt abaixo constrói uma única versão, com o que realmente se usa. O resto fica de fora de propósito.

O que o prompt constróigatilho por webhook, etapa de transformação, ação http, fluxos lineares, histórico de execuções, novas tentativas, segredos, reexecução
O que fica de foramarketplace de 7.000 conectores, oauth para tudo, gatilhos por consulta periódica

O que uma alternativa mínima ao Zapier precisa

  • gatilhos por webhook com um endpoint copiável e um payload de exemplo
  • fluxos lineares com etapas de filtro, transformação, requisição HTTP, espera e email
  • referências a segredos separadas da configuração do fluxo
  • histórico de execuções com entrada, saída, duração e nova tentativa de cada etapa
  • reexecução manual a partir de uma etapa que falhou e ativar ou desativar fluxos

Modelo de dados

Workflow, Step, SecretReference, Run, StepRun

Integrações

webhooks, APIs HTTP, email, Queues

Contexto técnico

Workers, Workflows, D1

A regra de segurança

Oculte os segredos nos logs, assine os hooks de entrada quando possível e torne as novas tentativas idempotentes.

O que não se faz de propósito

Não crie um marketplace público de conectores, uma tela com ramificações, execução de código arbitrário nem gatilhos por consulta periódica.

O prompt completo

Escolha o seu stack, copie o prompt e cole no seu agente de código (Claude Code, Cursor, Codex…).

Você vai construir um produto de software pronto para produção chamado “Whenhook”, uma alternativa deliberadamente focada ao Zapier. Construa uma fatia vertical completa e utilizável, não uma landing page, nem um mockup estático, nem um amontoado de componentes soltos.

ACORDO DE TRABALHO
Antes de escrever código de implementação, monte um plano técnico curto que nomeie as rotas ou páginas, as server actions ou endpoints, as tabelas de dados, as transições de estado importantes, os limites de autorização, os jobs em segundo plano e os adaptadores externos. Se algo se contradisser, resolva a favor do público restrito e dos não-objetivos abaixo. Prefira uma arquitetura pequena e legível a abstrações especulativas, mas não deixe de fora persistência, validação, tratamento de erros nem testes.

DESCRIÇÃO DO PRODUTO
Usuário principal: uma equipe de operações que roda um conjunto conhecido de automações disparadas por webhooks.
Resultado principal: receber eventos, transformar dados e executar uma sequência curta de ações confiáveis.
Princípio do produto: otimize exatamente o fluxo abaixo em vez de copiar toda a amplitude do Zapier. Quem usa pela primeira vez deve entender o que fazer pela própria interface, sem tour nem documentação.

JORNADAS COMPLETAS DO USUÁRIO
Implemente todos estes fluxos pela interface real e pela camada de dados persistente:
1. Um operador cria um fluxo, recebe uma URL de webhook, captura um evento de exemplo, adiciona etapas de filtro, transformação, requisição HTTP e email, testa e depois ativa uma revisão publicada.
2. Um webhook assinado inicia uma execução, cada etapa consome a saída da anterior, uma espera é retomada de forma durável e o detalhe da execução mostra entradas e saídas com dados ocultos, durações e o status final.
3. Uma ação HTTP falha depois de erros que podem ser repetidos; o operador corrige a credencial, reexecuta a partir da etapa que falhou e conclui a execução sem repetir efeitos de etapas anteriores que já deram certo.

TELAS E ARQUITETURA DE INFORMAÇÃO
Construa estas telas como visões coerentes e responsivas. Cada tela precisa definir sua ação principal, ações secundárias, status visível, feedback de validação, estado vazio, estado de carregamento ou pendente, confirmação de sucesso e um estado de erro recuperável.
1. Lista de fluxos: estado ativado, URL do gatilho, revisão publicada, última execução, taxa de sucesso recente, falhas atuais, e ações de duplicar, desativar e criar.
2. Editor linear de fluxos: lista ordenada de etapas, ajustes do gatilho, configuração de filtros e transformações, referências a segredos, teste de cada etapa, controles para reordenar, validação e ação de publicar.
3. Console de webhooks e testes: endpoint copiável, estado do segredo de assinatura, payloads de exemplo capturados, cabeçalhos, prévia do esquema, evento de teste e erros de tamanho de payload.
4. Detalhe da execução: status e linha do tempo, número de tentativas por etapa, entrada e saída com dados ocultos, duração, categoria do erro, logs, reexecutar a partir da falha e controles para cancelar.

FUNCIONALIDADES PRINCIPAIS
1. gatilhos por webhook com um endpoint copiável e um payload de exemplo
2. fluxos lineares com etapas de filtro, transformação, requisição HTTP, espera e email
3. referências a segredos separadas da configuração do fluxo
4. histórico de execuções com entrada, saída, duração e nova tentativa de cada etapa
5. reexecução manual a partir de uma etapa que falhou e ativar ou desativar fluxos

COMPORTAMENTO DETALHADO E REGRAS DE NEGÓCIO
Trate isto como requisitos do produto garantidos no servidor, não como sugestões de interface:
1. As execuções de um fluxo ativado usam uma revisão publicada imutável; as edições ficam como rascunho até a validação passar e o operador publicar de novo de forma explícita.
2. Limite o tamanho do corpo e dos cabeçalhos dos webhooks, verifique as assinaturas configuradas antes de enfileirar, rejeite entregas repetidas já vencidas e deduplique eventos com uma chave do provedor ou gerada.
3. Resolva as expressões de campos somente a partir do gatilho e das saídas de etapas anteriores, valide caminhos e tipos ausentes, e mantenha filtros e transformações determinísticos.
4. Registre que uma etapa terminou antes de avançar, oculte os valores de credenciais em todos os lugares e exija chaves de idempotência estáveis para os efeitos de HTTP, email e reexecução manual que podem ser repetidos.

MODELO DE DADOS E CICLO DE VIDA
Projete um esquema relacional pequeno centrado em Workflow, Step, SecretReference, Run, StepRun. Antes de implementar, documente:
1. O propósito de cada tabela, sua chave primária, o limite de propriedade ou de tenant, timestamps, campos de status e atributos importantes.
2. Chaves estrangeiras, restrições de unicidade, check constraints, os índices que as telas citadas precisam e os limites de transação para mudanças que tocam vários registros.
3. As transições de estado ou de ciclo de vida permitidas, quem pode disparar cada uma, quais são terminais ou reversíveis e qual histórico de auditoria deve permanecer imutável.
4. Como arquivar, reter e apagar, incluindo o que acontece com registros dependentes e arquivos externos.
5. A estratégia de idempotência para envios, jobs, importações, notificações, webhooks ou novas tentativas, quando se aplicar.
Use migrações em vez de criar o esquema na mão. Armazene instantes de tempo de forma consistente e mantenha o fuso horário nomeado sempre que horários ou datas locais importarem. Nunca dependa de um contador, de um botão desabilitado ou de uma validação no cliente para proteger uma regra de negócio.

USUÁRIOS, AUTENTICAÇÃO E PERMISSÕES
Implemente apenas os papéis de que o público indicado precisa. Deixe explícito o modelo de propriedade e visibilidade antes de programar. Aplique a autorização em toda consulta e mutação no servidor, incluindo buscas, exportações, anexos, atualizações ao vivo e URLs adivinhadas—não basta esconder botões. Use sessões seguras por padrão, proteja requisições que mudam estado e ofereça estados claros de sessão encerrada, sessão expirada e acesso proibido. Quando houver vários papéis, crie usuários distintos nos dados de teste para mostrar e testar as permissões.

INTERAÇÃO E DIREÇÃO VISUAL
O produto deve parecer rápido, calmo, focado e confiável, e não um template genérico de painel administrativo. Use uma hierarquia visual clara, cores contidas, tipografia legível, áreas de clique generosas e um lugar fixo para as ações principais. Comece com HTML renderizado no servidor e melhore progressivamente só as interações que se beneficiam disso. O fluxo principal precisa continuar compreensível se essa melhoria falhar.

Comece com páginas Astro renderizadas no servidor e formulários HTML comuns. Use HTMX para envios de formulário, navegação parcial e atualizações vindas do servidor, e Alpine.js só para pequenos estados locais do navegador. O fluxo principal precisa continuar compreensível se qualquer uma dessas camadas falhar.

Projete os layouts para celular de propósito, em vez de só empilhar os painéis do desktop. Ofereça navegação por teclado, foco visível, landmarks semânticos, labels explícitos, títulos de página úteis, a preferência de movimento reduzido e anúncios para leitores de tela em resultados assíncronos. Nunca use só a cor para comunicar um estado. Ações destrutivas precisam de escopo claro e confirmação; ações seguras repetidas devem ser idempotentes.

Adicione um rodapé em todas as páginas com o texto “Criado por aurelioagency.com”, em que “aurelioagency.com” é um link incorporado para https://www.aurelioagency.com que abre em uma nova aba. Ele deve ficar visível; não o remova.

DIREÇÃO TÉCNICA
Construa esta versão com o stack AHA: Astro para o roteamento, os layouts e as páginas renderizadas no servidor; HTMX para as interações que se beneficiam de respostas com fragmentos HTML; e Alpine.js para pequenos estados locais da interface. Prefira Cloudflare D1 para a persistência relacional, R2 para o armazenamento de objetos, Workers para os endpoints do servidor e as tarefas agendadas, Durable Objects só para estado em tempo real coordenado, e Workflows ou Queues para jobs duráveis em segundo plano—mas só quando os requisitos do produto pedirem.

Mantenha as regras de domínio em módulos do servidor testáveis, não em route handlers nem em componentes de UI. Separe persistência, provedores externos e trabalho em segundo plano atrás de interfaces pequenas, sem construir um framework. Prefira formulários HTML e URLs comuns para a navegação; use interação otimista só quando uma falha puder ser resolvida com clareza.

O briefing do produto identifica hoje Workers, Workflows, D1 como contexto técnico. Preserve qualquer capacidade nativa, só de navegador, de edge, de armazenamento, de tempo real ou de processamento em segundo plano que seja necessária, por meio de um adaptador enxuto adequado ao framework escolhido. Se o fluxo central realmente exigir APIs nativas ou de navegador, mantenha esse ambiente como superfície principal de execução em vez de simular capacidades inacessíveis ou inventar uma superfície web desnecessária.

Integre com webhooks e APIs HTTP e email e Queues. Para cada integração:
- Liste as variáveis de ambiente necessárias em um .env.example sem segredos reais.
- Adicione um adaptador pequeno com timeouts, erros normalizados e uma versão falsa local determinística ou um modo de desenvolvimento.
- Verifique as assinaturas recebidas e deduplique os eventos do provedor quando possível.
- Mantenha as credenciais no servidor, criptografe em repouso os tokens de longa duração e oculte segredos e dados sensíveis dos logs.
- Defina novas tentativas, backoff e idempotência para qualquer efeito que possa se repetir.

SEGURANÇA E PRIVACIDADE
Oculte os segredos nos logs, assine os hooks de entrada quando possível e torne as novas tentativas idempotentes.
Valide, normalize e limite o tamanho de toda entrada não confiável no servidor. Escape o conteúdo renderizado por padrão, sanitize qualquer markup aceito de propósito, aplique rate limit a ações públicas ou sujeitas a abuso e use armazenamento de objetos privado com URLs autorizadas de curta duração para arquivos sensíveis. Colete só os dados pessoais de que o fluxo indicado precisa. Documente como os dados são retidos e apagados. Adicione proteções específicas para as partes mais arriscadas deste app, como uploads, redirecionamentos, requisições de saída, envio de e-mails, OAuth, webhooks, importação ou exportação de CSV e conexões em tempo real.

CENÁRIOS DE ACEITAÇÃO
Automatize estes cenários específicos do app no nível mais adequado:
1. Dada uma assinatura de webhook inválida, a requisição é rejeitada, nenhuma execução é criada e nenhuma parte do segredo nem do payload enviado aparece nos logs.
2. Dado um evento que não passa em um filtro, a execução termina como filtrada e as ações seguintes são puladas, em vez de serem marcadas como falhas.
3. Dado um timeout do destino depois de etapas anteriores bem-sucedidas, reexecutar a partir da etapa que falhou reaproveita a saída anterior guardada e não reenvia um email anterior.

TESTES
Adicione testes unitários focados em transições de estado, regras de autorização, normalização, cálculos de datas ou dinheiro e outras regras de domínio arriscadas. Adicione testes de integração para as restrições de persistência e para os caminhos de sucesso, timeout, nova tentativa e rejeição de cada adaptador externo. Adicione pelo menos um teste de navegador para cada jornada completa acima, incluindo um em tela pequena. Os testes devem usar dados isolados e rodar com um único comando documentado.

OPERAÇÃO E RECUPERAÇÃO DE FALHAS
Adicione logs estruturados no servidor com IDs de correlação por requisição, job ou evento, sem segredos nem dados sensíveis desnecessários. Faça os erros indicarem o que fazer, tanto na interface quanto nos logs. O trabalho em segundo plano deve mostrar os estados pendente, concluído, com falha e tentando de novo quando fizer sentido; nunca engula erros em silêncio. Inclua um guia seguro de migração e rollback do banco, dados de teste, notas de backup e restauração, o que acontece com dados externos na limpeza e uma rota básica de saúde ou diagnóstico adequada ao stack.

ENTREGÁVEIS
Entregue o aplicativo funcionando, as migrações, dados de teste representativos, os testes, o .env.example e um README curto. O README deve cobrir pré-requisitos, instalação local, variáveis de ambiente, migrações, comandos de dados de teste e de testes, deploy, configuração das integrações, backup e restauração, decisões de segurança e limitações conhecidas. Os dados de teste devem cobrir o caminho feliz e pelo menos um estado vazio, com falha, atrasado, expirado, arquivado ou com permissão restrita que importe para o produto.

DEFINIÇÃO DE PRONTO
O app está pronto quando uma pessoa nova consegue seguir o README, criar e migrar o banco, rodar o app, entrar com cada papel relevante, completar cada jornada citada com dados reais salvos, recarregar sem perder o estado, se recuperar das falhas comuns e usar a interface principal no celular e no desktop. Todos os cenários de aceitação passam, os limites de permissão estão cobertos por testes, nenhuma tela principal fica como placeholder e o crédito “Criado por aurelioagency.com” no rodapé aparece em todas as páginas.

NÃO-OBJETIVOS
Não crie um marketplace público de conectores, uma tela com ramificações, execução de código arbitrário nem gatilhos por consulta periódica.

O app que você criar com este prompt leva no rodapé “Criado por aurelioagency.com”.

Crie só uma parte

Prompts curtos para resolver a parte mais difícil sem construir tudo.

A porta do webhook, com segurança na entradaChecagem de assinatura, janelas de validade e deduplicação de eventos antes de qualquer coisa rodar.
Construa o receptor de webhooks de entrada para uma ferramenta de automação de fluxos: o portão que todo evento precisa passar antes que uma execução possa começar.

Verifique o esquema de assinatura configurado (HMAC sobre o corpo bruto é o caso comum) com comparação em tempo constante, sobre os bytes exatos recebidos: interpretar e depois reverificar é como as assinaturas quebram. Aplique uma janela de validade usando o carimbo de tempo do material assinado, para que uma requisição capturada e repetida uma hora depois seja rejeitada. Limite o tamanho do corpo e dos cabeçalhos antes de ler o payload inteiro.

Deduplique eventos: prefira o id de evento do provedor quando existir; caso contrário, derive uma chave de um hash do conteúdo assinado mais o carimbo de tempo. Uma chave duplicada responde sucesso, mas não inicia uma segunda execução: os provedores repetem quando a resposta demora, então responda rápido e passe o trabalho para a fila de execuções de forma assíncrona.

Em qualquer rejeição, registre só a categoria do motivo: nada de bytes do payload, nada de valores de cabeçalhos, nenhum fragmento do segredo. O tráfego rejeitado é justamente o que você não deve arquivar.

Pronto quando: um corpo adulterado for rejeitado em tempo constante, uma captura repetida for recusada por vencida, uma entrega reenviada iniciar exatamente uma execução, e os logs de rejeição não tiverem nenhum conteúdo do payload.
Reexecutar a partir da etapa quatro sem disparar de novo a etapa doisGuardar a saída de cada etapa torna as novas tentativas cirúrgicas, e não no tiro de escopeta.
Construa a reexecução a partir da falha para um executor de fluxos lineares: quando a etapa quatro morre, corrija a causa e retome da etapa quatro, com as etapas um a três sem rodar de novo.

A base é a persistência: depois que cada etapa termina, registre de forma durável a sua saída e o seu status antes de avançar. Uma execução é uma cadeia de pontos de controle, não uma passada só na memória. Quando o operador reexecuta a partir da etapa que falhou, carregue as saídas guardadas de todas as etapas anteriores e entregue-as como se a execução nunca tivesse parado: o email da etapa dois que já saiu não pode ser enviado de novo, e a chamada HTTP da etapa três não pode se repetir.

A etapa reexecutada precisa de idempotência para o caso nebuloso em que falhou depois de causar efeitos (um timeout após uma gravação bem-sucedida no destino): cada etapa com efeitos carrega uma chave de idempotência estável por (execução, etapa) para que o destino possa deduplicar.

Registre a linhagem de reexecuções, com número de tentativas e carimbos de tempo por etapa, e marque o status final da execução pela última tentativa. Limite as novas tentativas automáticas; reexecutar além do limite é decisão de uma pessoa.

Pronto quando: reexecutar uma etapa com falha reaproveitar as saídas anteriores guardadas byte a byte, os efeitos anteriores nunca se repetirem, e o histórico da execução mostrar cada tentativa.
Editar um fluxo que está rodando agora mesmoRevisões publicadas imutáveis; rascunhos não existem para o sistema até a validação dizer que sim.
Construa o gerenciamento de revisões para uma ferramenta de automação de fluxos, para que editar nunca altere o que está em execução.

Publicar tira uma foto do fluxo (etapas, ordem, configuração, referências a segredos) em uma revisão imutável. O endpoint do gatilho sempre executa a revisão publicada atual. As edições se acumulam em um rascunho que não tem nenhum efeito em execução até o operador publicar de novo; um rascunho pela metade nunca pode ser aquilo em que um webhook dispara. Publicar valida primeiro: configurações de etapas completas, referências a segredos que possam ser resolvidas, expressões de campos que apontem só para etapas que existem antes, e caso contrário recusa com erros precisos.

A regra de concorrência: uma execução fixa a sua revisão ao começar e termina nela, mesmo que uma revisão nova seja publicada no meio. Duas execuções de revisões diferentes podem rodar ao mesmo tempo; o histórico de cada execução registra qual revisão usou, então depurar uma falha antiga mostra o fluxo como era naquele momento, e não como é agora.

Desativar um fluxo interrompe as execuções novas na hora e deixa as que estão em andamento terminarem.

Pronto quando: publicar no meio de uma execução não mudar nada para essa execução, um rascunho com uma expressão quebrada não puder ser publicado, e cada execução histórica mostrar a sua própria revisão.
O resolvedor de caminhos com pontos que falha em voz altaExpressões de campos determinísticas a partir do gatilho e das saídas anteriores, com erros tipados.
Construa o resolvedor de expressões de campos para uma ferramenta de fluxos: o mecanismo pelo qual a etapa quatro diz “use o email do gatilho e o id da resposta da etapa dois”.

As expressões são caminhos com pontos e índices de array (trigger.body.customer.email, steps.http1.response.items.0.id) que só podem ser resolvidos contra o payload do gatilho e as saídas de etapas anteriores; referências para a frente falham na validação ao publicar. Em execução, a resolução é estrita e tipada: um caminho ausente produz um erro claro que nomeia o caminho e a etapa que precisava dele, e não um undefined interpolado em silêncio dentro de um corpo HTTP. Distinga ausente de null legítimo, porque as APIs de origem querem dizer coisas diferentes com cada um.

Mantenha a avaliação determinística: sem acesso ao relógio, sem aleatoriedade, sem rede; as mesmas entradas devem ser resolvidas de forma idêntica ao reexecutar, senão a reexecução a partir da falha produz requisições diferentes das da execução original.

Os filtros usam o mesmo resolvedor com operadores de comparação. Um filtro que dá falso termina a execução como filtrada, um estado de conclusão bem-sucedido em que as etapas seguintes são puladas, nunca como falha. Um alerta que acorda alguém porque um filtro fez o seu trabalho é um erro de projeto.

Pronto quando: um caminho ausente falhar nomeando o caminho exato, as reexecuções forem resolvidas de forma idêntica, e as execuções filtradas aparecerem como filtradas e não como falhas.

Perguntas frequentes

Quanto custa o Zapier se eu continuar assinando?

O Zapier custa de US$30 a US$69 por mês nos planos pagos públicos, ou seja, de US$360 a US$828 por ano. Um substituto próprio e focado custa o seu tempo de construção mais uma hospedagem quase de graça.

Qual stack devo usar para criar uma alternativa ao Zapier?

O prompt desta página vem em quatro versões: a stack AHA (Astro, HTMX, Alpine.js), Next.js, Laravel e Ruby on Rails. O contexto técnico deste produto é Workers, Workflows, D1. Escolha a stack que você já conhece: o escopo importa mais que o framework.

Quais funções um substituto mínimo do Zapier precisa ter?

Uma v1 útil precisa de: gatilhos por webhook com um endpoint copiável e um payload de exemplo; fluxos lineares com etapas de filtro, transformação, requisição HTTP, espera e email; referências a segredos separadas da configuração do fluxo; histórico de execuções com entrada, saída, duração e nova tentativa de cada etapa; reexecução manual a partir de uma etapa que falhou e ativar ou desativar fluxos. Todo o resto é escopo inflado até você sentir falta de verdade.

O que devo deliberadamente não construir?

Não crie um marketplace público de conectores, uma tela com ramificações, execução de código arbitrário nem gatilhos por consulta periódica.

Esta construção também substitui n8n e Pipedream?

Sim. Zapier, n8n e Pipedream resolvem o mesmo trabalho central: receber eventos, transformar dados e executar uma sequência curta de ações confiáveis. A v1 desta página cobre o que a maioria das pessoas usa em qualquer um dos três, então uma única construção focada substitui o que você paga hoje.

Qual é a diferença para o Zapier?

O n8n faz quase tudo o que o Zapier faz, sem assinatura, e os seus dados ficam com você. A comparação ponto a ponto está na página.

Os meus dados são meus?

Sim. Com uma ferramenta de código aberto instalada do seu lado, seus arquivos ficam na sua máquina ou no seu servidor. Ninguém pode encerrar a sua conta nem mudar o preço.

Ver os 22 apps →

Sem tempo para fazer?

A gente faz para você.

Se você prefere que alguém instale, conecte às suas ferramentas e deixe funcionando, é exatamente isso que fazemos na Aurelio.

Agendar uma auditoria de automação