Splitting de Workflows: Criando Lógica Condicional no n8n
O que você vai aprender nesta página
- Definir o que é splitting (ramificação condicional) no n8n
- Identificar por que e quando aplicar essa técnica
- Conhecer os nós essenciais – IF, Switch e Merge – e suas configurações críticas
- Construir um fluxo multi‑ramo, passo a passo, a partir de um fluxo linear
- Controlar a ordem de execução, paralelismo e a opção Always Output Data
- Aplicar boas práticas e evitar armadilhas comuns em ambientes de produção
Entendendo o Conceito de Splitting
Splitting em workflows é como criar um ponto de decisão em um processo automatizado. Imagine que você é um gerente de atendimento ao cliente que precisa distribuir tickets de suporte: tickets simples vão para o nível 1, problemas técnicos vão para especialistas, e reclamações urgentes vão direto para supervisores.
No n8n, splitting funciona exatamente assim - você cria pontos onde o workflow "decide" qual caminho seguir baseado em condições específicas.
O que é Splitting de Workflow?
No n8n, um workflow percorre naturalmente um único caminho sequencial. Splitting transforma esse caminho em ramificações paralelas: cada item é avaliado por um nó condicional (IF ou Switch) e roteado ao ramo que corresponde aos seus dados.
Splitting ≠ Split Out
- Split Out: Quebra uma lista em itens individuais para processamento em loop
- Splitting condicional: Mantém o item intacto e decide qual caminho ele seguirá
Por que e quando usar Splitting?
- Benefícios
- Antes vs Depois
Situação | Benefício do Splitting |
---|---|
Filas de suporte com múltiplos SLAs | Priorização automática conforme urgência e plano |
Campanhas de marketing multilíngues | Mensagens corretas por país ou segmento sem scripts extras |
Processamento de pagamentos | Diferenciar rotas de antifraude para valores altos ou clientes novos |
Aprovações corporativas | Automação de fluxos de aprovação baseados em valor e categoria |
Triagem de leads | Distribuição automática para equipes especializadas |
Workflow Linear
Limitações:
- Todos os itens seguem o mesmo caminho
- Não há personalização baseada em dados
- Lógica rígida e inflexível
- Retrabalho e atrasos
- Falta de personalização
Workflow Inteligente
Vantagens:
- Lógica adaptativa baseada em dados
- Múltiplos caminhos de processamento
- Automação inteligente e personalizada
- Escalabilidade aumentada
- Eliminação de lógica manual
Nós Essenciais para Splitting
- Comparativo Rápido
- Node IF
- Node Switch
- Node Merge
Nó | Finalidade | Saídas | Dicas Rápidas |
---|---|---|---|
IF | Decisão binária | ,
| Combine condições com AND/OR; ative Always Output Data se for fazer merge depois |
Switch | Seleção multicondicional | ,
| Dois modos: Rules (comparação direta) ou Expression (lógica JavaScript) |
Merge | Reunir ramificações | — | Estratégias Wait → All ou Merge By Key garantem dados completos |
Node IF: Decisões Simples (Sim/Não)
Quando usar: Para condições binárias simples onde você precisa de apenas dois caminhos.
"Se o valor do pedido for maior que R$ 1000, envie para aprovação manual. Caso contrário, processe automaticamente."
Configurações Críticas:
- Always Output Data: Garante que mesmo ramos "vazios" produzam dados
- Combine Conditions: Use AND/OR para lógicas complexas
- Data Type: Certifique-se de comparar tipos compatíveis - veja transformações de dados
// Lógica do node IF
if (valor_pedido > 1000) {
// Caminho "true" - Aprovação manual
enviarParaAprovacao();
} else {
// Caminho "false" - Processamento automático
processarAutomaticamente();
}
Copie e cole este template na dashboard do n8n:
{
"name": "1 - Node IF Simples (Exemplo)",
"nodes": [
{
"parameters": {},
"type": "n8n-nodes-base.manualTrigger",
"typeVersion": 1,
"position": [
0,
0
],
"id": "cc141f51-104f-4418-8855-7d60d0f5bf37",
"name": "Pedido Recebido (Clique)"
},
{
"parameters": {
"conditions": {
"options": {
"caseSensitive": true,
"leftValue": "",
"typeValidation": "strict",
"version": 2
},
"conditions": [
{
"id": "a3c56011-c465-4d36-865d-ea19ed69533e",
"leftValue": "={{ $json.valor_pedido }}",
"rightValue": 1000,
"operator": {
"type": "number",
"operation": "gt"
}
}
],
"combinator": "and"
},
"options": {}
},
"type": "n8n-nodes-base.if",
"typeVersion": 2.2,
"position": [
440,
0
],
"id": "9c878dfe-3b58-421a-af0b-28b854f5627c",
"name": "Valor > R$ 1000 "
},
{
"parameters": {},
"type": "n8n-nodes-base.noOp",
"typeVersion": 1,
"position": [
800,
-120
],
"id": "05194991-a2f7-476b-9d38-86caffa0228a",
"name": "Processamento Automático"
},
{
"parameters": {},
"type": "n8n-nodes-base.noOp",
"typeVersion": 1,
"position": [
800,
140
],
"id": "82a80168-402c-4045-8a31-9880ac4be86c",
"name": "Aprovação Manual"
},
{
"parameters": {
"mode": "raw",
"jsonOutput": "{
"valor_pedido": 1500
}
",
"options": {}
},
"type": "n8n-nodes-base.set",
"typeVersion": 3.4,
"position": [
220,
0
],
"id": "6693b086-a4a5-4be4-a2dd-ad9d863d0410",
"name": "Valor do Pedido"
}
],
"pinData": {},
"connections": {
"Pedido Recebido (Clique)": {
"main": [
[
{
"node": "Valor do Pedido",
"type": "main",
"index": 0
}
]
]
},
"Valor > R$ 1000 ": {
"main": [
[
{
"node": "Processamento Automático",
"type": "main",
"index": 0
}
],
[
{
"node": "Aprovação Manual",
"type": "main",
"index": 0
}
]
]
},
"Valor do Pedido": {
"main": [
[
{
"node": "Valor > R$ 1000 ",
"type": "main",
"index": 0
}
]
]
}
},
"active": false,
"settings": {
"executionOrder": "v1"
},
"versionId": "9f87682e-bf1b-4d70-8256-3137f28ffa9a",
"meta": {
"templateCredsSetupCompleted": true,
"instanceId": "5d478e0a2f4e8d45c4e0abcf4fbfa908e6f06b0598ed1dff66e5f3280b44e520"
},
"id": "EJZFhzQGa087iUZQ",
"tags": []
}
Node Switch: Decisões Múltiplas
Quando usar: Para múltiplas condições onde você precisa de vários caminhos diferentes.
- Google Ads → Equipe de Marketing Pago
- Redes Sociais → Equipe de Social Media
- Website → Equipe de Vendas Inbound
- Indicação → Equipe de Relacionamento
Modos de Operação:
- Rules: Comparação direta (mais simples)
- Expression: Lógica JavaScript (mais flexível)
// Lógica do node Switch
switch (origem_lead) {
case "google_ads":
// Caminho 1
enviarParaMarketingPago();
break;
case "redes_sociais":
// Caminho 2
enviarParaSocialMedia();
break;
case "website":
// Caminho 3
enviarParaVendasInbound();
break;
case "indicacao":
// Caminho 4
enviarParaRelacionamento();
break;
default:
// Caminho padrão
enviarParaTriagem();
}
Node Merge: Reunindo Ramificações
Quando usar: Quando diferentes caminhos precisam convergir para uma ação final comum.
Estratégias de Merge:
- Wait → All: Aguarda todos os ramos terminarem
- Merge By Key: Combina dados baseado em chaves específicas
- Append: Adiciona dados sequencialmente
Saiba mais sobre manipulação de dados.
Implementação Prática: Exemplo Completo
Cenário: Sistema de Aprovação de Despesas
Vamos criar um workflow que automatiza a aprovação de despesas corporativas com base em valor e categoria:
- Despesas até R$ 500: Aprovação automática
- Despesas R$ 501-2000: Aprovação do supervisor
- Despesas acima de R$ 2000: Aprovação da diretoria
- Categoria "Viagem": Sempre vai para RH (independente do valor)
Diagrama Completo do Workflow
Construção Passo a Passo
- 1. Webhook/Trigger
- 2. Extrair Dados
- 3. IF Categoria
- 4. Switch Valor
- 5. Ações Finais
- 6. Merge (Opcional)
1. Webhook/Trigger – Receber Dados
Objetivo: O usuário envia um ticket de despesa, disparando o workflow.
{
"funcionario": "João Silva",
"valor": 1500.00,
"categoria": "Material de Escritório",
"descricao": "Notebooks para equipe",
"data": "2024-01-15",
"prioridade": "normal",
"plano_suporte": "Premium"
}
2. Set/Function – Extrair Dados Essenciais
Objetivo: Extrair
priority
, supportPlan
, description
, valor
, categoria
.// Extrair dados essenciais
const dados = {
funcionario: $json.funcionario,
valor: parseFloat($json.valor),
categoria: $json.categoria?.toLowerCase(),
prioridade: $json.prioridade || 'normal',
descricao: $json.descricao,
data: $json.data
};
return dados;
3. IF Categoria – Verificar se é Viagem
Configuração do IF Node "Verificar Categoria":
- Condition:
{{ $json.categoria === "viagem" }}
- Always Output Data: ✅ Ativado
- true → Caminho RH
- false → Continua análise por valor
4. Switch Valor – Análise por Valor
Configuração do Switch Node "Análise por Valor":
- Rule 1:
→ Aprovação Automática{{ $json.valor <= 500 }}
- Rule 2:
→ Supervisor{{ $json.valor > 500 && $json.valor <= 2000 }}
- Rule 3:
→ Diretoria{{ $json.valor > 2000 }}
5. Ações Finais – Processar Cada Caminho
- Caminho RH
- Aprovação Automática
- Supervisor
- Diretoria
Caminho RH (Viagens):
{
"aprovador": "RH",
"mensagem": "Despesa de viagem para análise de política corporativa",
"prioridade": "normal",
"sla": "2 dias úteis"
}
Caminho Aprovação Automática:
{
"status": "aprovado",
"aprovador": "sistema",
"data_aprovacao": "{{ $now }}",
"observacao": "Aprovação automática - valor dentro do limite"
}
Caminho Supervisor:
{
"aprovador": "supervisor",
"email_destino": "supervisor@empresa.com",
"template": "aprovacao_supervisor",
"dados_despesa": "{{ $json }}",
"sla": "1 dia útil"
}
Caminho Diretoria:
{
"aprovador": "diretoria",
"email_destino": "diretoria@empresa.com",
"template": "aprovacao_diretoria",
"urgencia": "alta",
"dados_despesa": "{{ $json }}",
"sla": "4 horas"
}
6. Merge – Reunir Resultados
Objetivo: Se etapas posteriores exigirem o conjunto completo de itens, configure Wait → All.
Configurações importantes:
- Mode: Wait
- Strategy: All
- Timeout: 30 minutos (para aprovações)
Ações finais após merge:
- Atualizar CRM
- Logar métricas
- Enviar notificação final
- Encerrar execução
Lógica de Execução e Controle
Entendendo a Ordem de Execução
- Ordem de Execução
- Always Output Data
- Paralelismo
- Ordem: O n8n executa o primeiro ramo que finalizar
- Paralelismo: Ramos são executados em paralelo por padrão
- Sincronização: Use Merge se precisar aguardar todos os ramos
- Timeout: Configure timeouts para evitar execuções infinitas
Always Output Data
Função: Garante que mesmo um ramo "vazio" produza um item, evitando falhas na junção.
✅ Use quando:
- Vai fazer merge depois
- Precisa garantir continuidade do fluxo
- Alguns ramos podem não ter dados
❌ Não use quando:
- Quer que ramos vazios parem a execução
- Dados vazios causariam problemas downstream
Exemplo prático:
// Sem Always Output Data
if (condicao_raramente_verdadeira) {
return dados; // Só executa se condição for verdadeira
}
// Ramo pode ficar "vazio" e quebrar o merge
// Com Always Output Data
if (condicao_raramente_verdadeira) {
return dados;
} else {
return {}; // Sempre retorna algo, mesmo vazio
}
Sintaxe JavaScript em Expressões
Sintaxe Recomendada:
// ✅ Sintaxe padrão (mais limpa)
{{ $json.valor > 1000 }}
// ✅ Sintaxe com brackets (necessária para propriedades especiais)
{{ $json["valor-especial"] > 1000 }}
// ✅ Tratamento de tipos
{{ parseInt($json.valor) > 1000 }}
// ✅ Tratamento de valores nulos/undefined
{{ ($json.valor || 0) > 1000 }}
// ✅ Verificação de existência
{{ $json.valor !== undefined && $json.valor > 1000 }}
Evite:
// ❌ Pode causar erros com propriedades undefined
{{ $json.valor_inexistente > 1000 }}
// ❌ Sem tratamento de tipos
{{ $json.valor_string > 1000 }}
// ❌ Sem verificações de segurança
{{ $json.nested.deep.property }}
Paralelismo e Performance
Em instâncias self-hosted: Habilite filas Redis/RabbitMQ para processar ramos em paralelo.
Configuração para alta performance:
- Queue Mode: Ativado
- Concurrent Executions: 10-50 (baseado na capacidade)
- Timeout: Configurado por tipo de processo
- Retry Policy: Configurada para falhas temporárias
Performance em Produção
Processamento Distribuído:
- Concurrent Executions: 10-50 baseado na capacidade do servidor
- Queue Mode: Para processamento distribuído e alta concorrência
- Worker Scaling: Ajuste conforme demanda
Estratégia de Timeout:
- Timeout Strategy: 30s operações simples, 5min complexas
- Connection Timeout: 10s para APIs externas
- Retry Backoff: Exponencial com jitter
Monitoramento:
- Métricas de Performance: Latência, throughput, taxa de erro
- Alertas: Para timeouts e falhas de execução
- Logs Estruturados: Para debugging e análise
Monitoramento de Splitting
Eficiência de Roteamento:
- Split Efficiency: % de dados que seguem o caminho esperado
- Route Distribution: Distribuição de itens por ramo
- Condition Accuracy: Taxa de acerto das condições
Performance por Ramo:
- Branch Performance: Tempo médio por ramo de execução
- Bottleneck Detection: Identificação de gargalos específicos
- Parallel Efficiency: Eficácia do processamento paralelo
Qualidade e Confiabilidade:
- Error Rate: Falhas por tipo de condição
- Retry Success Rate: Taxa de sucesso nas reexecuções
- Data Quality: Integridade dos dados em cada ramo
Padrões Avançados de Splitting
- Splitting Sequencial
- Splitting Paralelo
- Splitting com Merge
Splitting Sequencial (Cascata)
Para lógicas mais complexas, você pode encadear múltiplos splits - veja mais sobre subworkflows:
- Visão Geral
- Exemplo Prático
- Fluxo Completo
Conceito Simplificado:
Estrutura em Cascata:
- Nível 1: Categorização inicial
- Nível 2: Refinamento por prioridade
- Nível 3: Decisão final por contexto
Sistema de Suporte Técnico - Passo a Passo:
1. Primeiro Split - Categoria:
2. Segundo Split - Criticidade:
3. Terceiro Split - Cliente:
Exemplo de um Caminho Completo:
Resultado Final:
- Software → Alta Criticidade → Cliente VIP = Especialista com SLA de 1 hora
Estrutura de Decisão em 3 Níveis:
- Primeiro Split: Tipo de problema (Software/Hardware/Rede)
- Segundo Split: Criticidade (Baixa/Média/Alta)
- Terceiro Split: Cliente (VIP/Standard)
Resultado: 18 combinações possíveis (3 × 3 × 2) com tratamento específico para cada uma
Splitting Paralelo
Quando você precisa executar múltiplas verificações simultaneamente:
Splitting com Merge
Após dividir o fluxo, você pode reunir os caminhos usando um Merge node:
Quando usar: Quando diferentes caminhos precisam convergir para uma ação final comum.
Modos de Merge Disponíveis:
- Append: Concatena todos os dados de entrada
- Keep Key Matches: Mantém apenas itens com chaves correspondentes
- Remove Key Matches: Remove itens duplicados por chave
- Pass-through: Passa dados do primeiro input que chegar
// Exemplo: Processar pedido
Pedido → IF (Cliente VIP?)
├── TRUE → Desconto VIP →
└── FALSE → Desconto Padrão →
↘
Merge → Processar Pagamento
Debugging: Ferramentas e Técnicas
Debugging de Condições
1. Adicione um Edit Fields (Set) antes do split:
{
"debug_valor": "{{ $json.categoria }}",
"debug_tipo": "{{ typeof $json.categoria }}",
"debug_condicao": "{{ $json.categoria === 'urgente' }}",
"debug_timestamp": "{{ new Date().toISOString() }}"
}
2. Use Expression Editor para testar condições:
- Teste expressões isoladamente
- Verifique tipos de dados
- Confirme valores antes de aplicar no workflow
3. Ative logging no Code node:
// Log detalhado para debug
console.log('Splitting Debug:', {
item: $input.item,
condition: $input.item.json.categoria === 'urgente',
itemIndex: $itemIndex,
timestamp: new Date().toISOString()
});
return $input.item;
Ferramentas de Debugging
Ferramentas Built-in:
- Execution History: Visualize dados em cada node
- Debug Helper: Insira breakpoints visuais
- Data Pinning: Congele dados para testes consistentes
Ferramentas Externas:
- Webhook.site: Para inspecionar payloads HTTP
- Postman: Para testes manuais de APIs
- Browser DevTools: Para debugging de expressões JavaScript
Troubleshooting: Problemas Comuns
- Workflow Para na Condição
- Caminho Errado
- Multiple Output Branches
❌ Problema: Workflow Para na Condição
O workflow executa até o node de splitting e não continua.
Diagnóstico:
- Verifique se a condição está retornando o valor esperado
- Teste a expressão no Expression Editor
- Confirme se há dados na entrada do node
Solução:
- ❌ Incorreto
- ✅ Correto
{{ $json.valor > "1000" }} // Comparando número com string
{{ $json.valor > 1000 }} // Comparando número com número
Saiba mais sobre expressões JavaScript e tipos de dados.
❌ Problema: Caminho Errado Sendo Executado
Os dados seguem por um caminho diferente do esperado.
Diagnóstico:
{
"debug_valor": "{{ $json.valor }}",
"debug_tipo": "{{ typeof $json.valor }}",
"debug_condicao": "{{ $json.valor > 1000 }}"
}
Soluções comuns:
- Converta tipos:
{{ parseInt($json.valor) > 1000 }}
- Trate valores nulos:
{{ ($json.valor || 0) > 1000 }}
- Use trim para strings:
{{ $json.categoria.trim() === "Viagem" }}
Para mais informações sobre tratamento de erros.
❌ Problema: Erro em Ramificação Específica
Uma ramificação falha mas o workflow continua nas outras.
Solução: Use Error Trigger para capturar erros em ramificações:
- Error Trigger captura falhas de qualquer node do workflow
- Configure Error Workflow específico para tratar falhas de splitting
- Use Continue On Fail em nodes críticos para não quebrar outras ramificações
❌ Problema: Multiple Output Branches
Switch node criando saídas inesperadas.
Solução: Configure adequadamente o Mode:
- "Rules": Para múltiplas regras independentes
- "Expression": Para lógica JavaScript personalizada
Configurações Importantes:
- Send data to all matching outputs: Controla se dados vão para todos os outputs que atendem as condições
- Fallback Output: Define comportamento para dados que não atendem nenhuma regra
Casos de Uso Comuns
- E-commerce
- Marketing
- Suporte
Boas Práticas e Armadilhas
- ✅ Boas Práticas
- ❌ Armadilhas Comuns
- Performance
- 🔧 Manutenibilidade
Boas Práticas Essenciais
Nomenclatura e Documentação:
- Nomeie nós de forma autoexplicativa (
,IF Urgente?
)SW Plano Suporte
- Documente regras no Description do nó para facilitar auditorias
- Use comentários para explicar lógicas complexas
Estrutura e Organização:
- Evite aninhar IF dentro de IF: prefira Switch quando houver >2 caminhos
- Split Out antes de splitting quando precisar percorrer cada linha de uma lista separadamente
- Centralize regras de negócio em nodes dedicados para facilitar manutenção
Testes e Validação:
- Teste cenários extremos (valores nulos, caminhos sem saída) antes de mover para produção
- Valide tipos de dados antes de fazer comparações
- Configure timeouts apropriados para cada tipo de processo
Armadilhas a Evitar
Problemas de Estrutura:
- Não aninhhe IFs excessivamente: Torna o workflow difícil de manter
- Evite splitting excessivo: Máximo 3-4 níveis de profundidade
- Não ignore o Always Output Data: Pode quebrar merges
Problemas de Dados:
- Não compare tipos diferentes:
"100" !== 100
- Não assuma dados sempre existem: Trate valores nulos/undefined
- Não ignore case sensitivity:
"VIAGEM" !== "viagem"
Problemas de Performance:
- Não crie nodes desnecessários: Use Switch ao invés de múltiplos IFs
- Não deixe execuções infinitas: Configure timeouts
- Não ignore recursos de paralelismo: Use filas quando apropriado
Otimização de Performance
Estratégias de Otimização:
- Minimize nodes desnecessários: Use Switch ao invés de múltiplos IFs sequenciais
- Cache resultados: Para condições computacionalmente caras
- Use paralelismo: Configure filas Redis/RabbitMQ para alta concorrência
Configurações Recomendadas:
n8n Cloud:
- Timeout: Limitado pela configuração da instância
- Concorrência: Baseado no plano contratado
- Paralelismo: Automático até o limite do plano
Self-hosted:
- Timeout: 30s para operações simples, 5min para complexas
- Retry Policy: 3 tentativas com backoff exponencial
- Memory Limit: Ajuste baseado no volume de dados
- Queue Mode: Redis/RabbitMQ para alta concorrência
- Worker Scaling: Múltiplos workers para processamento distribuído
Migração de IF Múltiplos para Switch
Cenário Comum: Workflows com múltiplos IFs aninhados que se tornaram difíceis de manter.
Antes: Múltiplos IFs Aninhados
// ❌ Estrutura complexa e difícil de manter
IF (categoria === "software") {
IF (prioridade === "alta") {
IF (cliente === "vip") {
// Ação específica
} else {
// Outra ação
}
} else {
// Mais IFs...
}
}
Depois: Um Switch Organizado
// ✅ Estrutura clara e eficiente
SWITCH (categoria + "_" + prioridade + "_" + cliente) {
case "software_alta_vip":
// Ação específica
break;
case "software_alta_standard":
// Outra ação
break;
default:
// Ação padrão
}
Benefícios da Migração:
- Manutenibilidade: Código mais limpo e fácil de entender
- Performance: Menos overhead de processamento
- Escalabilidade: Fácil adição de novos casos
- Debugging: Mais simples identificar problemas
Para padrões mais complexos, considere usar subworkflows.
Facilitar Manutenção
Nomenclatura Consistente:
Documentação Estruturada:
- Description: Explique o propósito do nó
- Notes: Adicione contexto de negócio
- Version Control: Documente mudanças importantes
Modularização:
Integração com Sub-workflows
Splitting + Execute Sub-workflow
Para lógicas complexas, combine splitting com Execute Sub-workflow:
Vantagens:
- Modularidade: Cada sub-workflow é independente e reutilizável
- Manutenção: Easier debugging e atualizações
- Performance: Sub-workflows podem rodar em paralelo
- Organização: Separa lógica complexa em componentes menores
Configuração:
- Workflow Principal: Contém o splitting logic
- Sub-workflows: Cada um com lógica específica de categoria
- Error Handling: Cada sub-workflow pode ter seu próprio tratamento de erro
- Workflow Trigger: Para comunicação entre workflows
// No Execute Sub-workflow node:
{
"categoria": "{{ $json.categoria }}",
"dados_originais": "{{ $json }}",
"workflow_origem": "{{ $workflow.name }}",
"timestamp": "{{ new Date().toISOString() }}"
}
Próximos Passos
- Merge Nodes: Como reunir fluxos divididos
- Error Handling: Tratamento de erros em fluxos condicionais
- Looping: Lógica de repetição em workflows
- Sub-workflows: Workflows aninhados
- Waiting: Controle de tempo e aguardo
- Execute Sub-workflow: Modularização avançada
Exercício Prático
Crie um workflow de aprovação de férias que:
- Funcionários CLT: Máximo 30 dias, aprovação do supervisor
- Funcionários PJ: Sem limite, apenas notificação
- Períodos de alta temporada: Sempre requer aprovação da diretoria
- Solicitações com menos de 30 dias de antecedência: Aprovação expressa
Dica: Use Switch aninhados e considere múltiplas condições simultâneas.
Resumo Rápido
Conceitos Fundamentais:
- Splitting = usar IF e Switch para criar múltiplos caminhos de execução
- Escolha IF para decisões binárias; Switch para múltiplos casos
- Não confunda com Split Out (que quebra listas em itens individuais)
Implementação Prática:
- Combine ramificações com Merge quando necessário, mantendo integridade dos dados
- Ative Always Output Data em ramos críticos para evitar execuções "mortas"
- Configure timeouts e retry policies apropriados
Boas Práticas:
- Nomeie nós claramente para facilitar manutenção
- Documente regras complexas no Description
- Teste cenários extremos antes de produção
- Use paralelismo para alta performance
Ordem de Execução:
- O n8n executa ramos em paralelo por padrão
- Use Merge se precisar aguardar todos os ramos
- Configure filas Redis/RabbitMQ para processamento distribuído
Fluxo de Aprendizado Recomendado
Com esses fundamentos, você está pronto para projetar workflows n8n que se adaptam dinamicamente a qualquer cenário de negócios, mantendo o código enxuto e a manutenção simples.