Expressões no n8n: como usar dados de um nó no outro sem errar
Expressões no n8n: veja como puxar dados entre nós, evitar erros frequentes e acelerar automações com técnicas práticas e exemplos claros.
Por Rodrigo Monteiro30 de outubro de 202613 min de leitura

Resumo em 30 segundos
- 01Ative expressão e valide: Use o ícone “=” para habilitar {{ }}, confira o preview e ajuste o caminho antes de executar o fluxo.
- 02Referencie com estabilidade: Prefira $(‘Nome do Nó’).first().json.campo ou $node[“Nome do Nó”].json.campo; use .all()[i] quando houver múltiplos itens e respeite maiúsculas/minúsculas.
- 03Use o Item Browser: Arraste o campo da árvore de dados para a expressão para obter o caminho exato e evitar typos em chaves aninhadas.
- 04Formate texto, datas e números: Limpe strings (trim, replace, normalize), formate datas com Luxon ($now/DateTime.toFormat) e moedas com Intl.NumberFormat(‘pt-BR’, { currency: ‘BRL’ }).
- 05Evite “undefined” com guardas: Acesse com optional chaining e ?? (ex.: $json.user?.id ?? ”), use bracket notation para chaves com espaço e reexecute o nó anterior para atualizar o preview.
- 06Trate JSON vs string: Quando APIs retornarem texto JSON, aplique JSON.parse antes de acessar campos; normalize datas antes de comparar ou formatar.
- 07Escolha o modo certo no Code: Run Once for All Items para agregações e Run Once for Each Item para transformar item a item; preserve pairedItem ao mapear $input.all().
- 08Priorize nós nativos pela performance: Operações comuns em Set/IF/Item Lists rodam em milissegundos, enquanto Code pode adicionar 1–3 s por execução; evite $(‘Node’) dentro do Code para não travar o runner.
O quebra-cabeça do n8n: puxar dados de um nó para outro parece simples até a primeira expressão dar erro misterioso. Quem nunca viu “undefined” bem no meio do fluxo?
Por que isso importa agora: construímos automações cada vez mais ousadas e, sem dominar expressões no n8n, o fluxo vira uma caixa-preta difícil de manter. Expressão é a cola que liga dados entre nós. Quando você entende como apontar para o campo certo, o ganho de tempo e a confiança no resultado aumentam de forma clara.
O problema dos tutoriais rasos: muitos explicam “copie este caminho e cole aqui”, mas não mostram como ler o preview, checar o contexto do item ou tratar valores ausentes. A solução rápida funciona até a primeira mudança no payload e, aí, o castelo cai.
O que você vai levar daqui: um guia direto ao ponto para referenciar dados com segurança. Vamos ver onde as expressões vivem, como pegar campos do nó anterior ou de nós mais antigos, funções úteis para texto, datas e números, e como decifrar mensagens de erro. Fecho com um critério prático para decidir quando usar apenas expressão e quando partir para o nó Code.
O que são expressões e onde elas aparecem no n8n
Expressões no n8n em poucas palavras: são trechos dentro de {{ }} que rodam JavaScript simples para ler e transformar dados em tempo de execução. Elas aparecem em quase todos os campos de nós que aceitam texto e deixam o fluxo realmente dinâmico.
Como a sintaxe {{ }} funciona e quando o campo vira expressão
Expressões são {{ }}: tudo que estiver entre chaves duplas é avaliado quando o workflow executa. Você pode puxar valores, montar strings e fazer contas direto no campo, por exemplo {{ $json.email }} ou “Olá, {{ $json.firstName }}”.
As expressões são avaliadas por item, então o mesmo campo é reprocessado para cada entrada do nó. Um campo “vira” expressão quando você ativa o modo de expressão no editor ou quando o valor começa com = no JSON do workflow exportado.
Ativando o modo expressão com o ícone ‘=’ e entendendo o preview
Ative com “=”: no campo do nó, clique no ícone = para mudar de valor fixo para expressão. O campo muda o visual e abre o editor de expressão.
O editor mostra pré-visualização ao vivo baseada nos dados da última execução. Se o preview resolve como esperado, o valor será o mesmo na hora de rodar. Isso evita tentativas e erros no escuro.
Entendendo $json, $node[“Nome do Nó”], $input e contexto do workflow
$json é o item atual: use {{ $json.campo }} para ler o dado que entra no nó agora, inclusive aninhado como {{ $json.usuario.email }} ou arrays como {{ $json.itens[0].sku }}.
Para pegar dados de outro ponto do fluxo, referencie pelo nome: {{ $(“HTTP Request”).item.json.data.id }}. Esse formato costuma ser mais estável do que depender só do encadeamento. Use .item para o item pareado; use .first() ou .all() apenas quando fizer sentido global.
Quando precisar ver mais de um item, recorra ao {{ $input.all() }}. Ele entrega todos os itens de entrada; {{ $input.first() }} e {{ $input.last() }} pegam extremos. Em muitos casos, {{ $input.item.json }} equivale a $json.
Usando Item Browser para localizar caminhos corretos antes de referenciar
Use o Item Browser: abra o editor de expressão e navegue no painel de dados à esquerda. Clique ou arraste o campo desejado.
O n8n insere o caminho completo com o nome exato do nó e a propriedade certa, reduzindo erros de digitação. O preview confirma na hora se o caminho está correto.
Pegando dados do nó anterior e de nós mais antigos
O caminho dos dados no fluxo: no n8n, você lê o item atual com $json e aponta para nós antigos pelo nome. Assim você evita surpresas quando o fluxo cresce.
Referenciando o último item com $json.campo e caminhos aninhados
$json lê o atual: use {{ $json.campo }} para pegar o dado que entra neste nó agora. Caminhos aninhados funcionam com ponto: {{ $json.cliente.endereco.cidade }} e arrays aceitam índice: {{ $json.itens[0].sku }}.
$json é atalho para $input.item.json e é reavaliado por item. Para chaves com espaços, use colchetes: {{ $json[‘nome completo’] }}. Essa leitura vale para o nó imediatamente anterior na cadeia.
Acessando nós específicos com $node[“Nome do Nó”].json.campo
Referencie pelo nome: para buscar de nós mais antigos, use {{ $(‘HTTP Request’).item.json.data.id }} ou {{ $node[“Webhook”].json.body.email }}. O nome do nó deve estar entre aspas e respeitar maiúsculas/minúsculas.
Prefira o item pareado com .item, que acompanha o item atual. Use .first() ou .all() só quando precisar de um valor global. Essa forma é mais estável que depender de $json após merges ou refactors.
Trabalhando com múltiplos itens: índices, $input.all() e arrays
Use $input.all(): quando precisar do lote inteiro, pegue todos os itens com {{ $input.all() }} e aplique map, filter e reduce. Exemplo: {{ $input.all().map(i => i.json.email).join(‘, ‘) }}.
Você também tem {{ $input.first() }} e {{ $input.last() }}. Em expressões simples, acesse arrays com índice numérico, como {{ $json.pedidos[0].total }}. Lembre que a maioria dos nós já roda por item, então muitas vezes você não precisa de loop.
Resgatando headers, query params e arquivos binários com segurança
Binário e headers: em Webhook e HTTP, os dados chegam separados como headers, params, query e body. Exemplos: {{ $node[“Webhook”].json.headers[‘user-agent’] }}, {{ $node[“Webhook”].json.query.ref }}, {{ $node[“Webhook”].json.body.email }}.
Arquivos ficam em $binary (atalho de $input.item.binary). Acesse o nome e tipo via algo como {{ $binary.meuArquivo.fileName }} e {{ $binary.meuArquivo.mimeType }}. Se um parâmetro pode faltar, use optional chaining e fallback: {{ decodeURIComponent($json.query?.ref ?? ”) }} para evitar quebras.
Funções úteis para texto, datas e números
Formate sem dor de cabeça: nas expressões do n8n, você pode tratar texto, datas e números direto no {{ }}. Use métodos nativos, o Luxon embutido para datas e proteja acessos com ?. e ??.
Strings: concatenar, normalizar acentos e limpar espaços
Limpe e una textos: concatene com {{ `${$json.nome} ${$json.sobrenome}`.trim() }}, remova espaços extras com {{ $json.texto.replace(/\s+/g, ‘ ‘).trim() }} e padronize com {{ $json.codigo.toUpperCase() }}.
Para remover acentos, use normalize(‘NFD’) e regex: {{ $json.nome.normalize(‘NFD’).replace(/\p{Diacritic}/gu, ”) }}. Para chaves com espaço: {{ $json[‘nome completo’].trim() }}. Esses padrões são comuns e funcionam bem nas expressões JavaScript do n8n.
Datas: new Date(), fuso horário e formatação com Intl.DateTimeFormat
Datas com Luxon: o n8n expõe $now, $today e DateTime (Luxon). Formate com {{ $now.toFormat(‘yyyy-MM-dd’) }}, some tempo com {{ $now.plus({ days: 7 }).toISO() }} e mude fuso com {{ $now.setZone(‘America/Sao_Paulo’).toFormat(‘HH:mm’) }}.
Para entrada ISO: {{ DateTime.fromISO($json.createdAt).toFormat(‘dd/MM/yyyy’) }}. Se preferir nativo, use {{ new Date($json.timestamp).toISOString() }}, mas o ecossistema do n8n recomenda toISO() e toFormat() do Luxon nas expressões.
Números: arredondar, casas decimais e moeda com Intl.NumberFormat
Formate números fácil: arredonde com {{ Math.round($json.valor) }}, suba com {{ Math.ceil($json.valor) }}, desça com {{ Math.floor($json.valor) }} e fixe casas com {{ Number($json.preco).toFixed(2) }}.
Para moeda, use Intl.NumberFormat: {{ new Intl.NumberFormat(‘pt-BR’,{ style:’currency’, currency:’BRL’ }).format($json.total) }}. Para parsing seguro, prefira {{ Number($json.quantidade) }} ou {{ parseFloat($json.preco) }} antes de formatar.
Definição de padrão: optional chaining e coalescência nula para evitar quebras
Use ?. e ??: acesse campos aninhados sem quebrar: {{ $json.usuario?.endereco?.cidade ?? ‘Sem cidade’ }}. Para arrays, use índice opcional: {{ $json.itens?.[0]?.sku ?? ” }}.
Combine com defaults em strings e números: {{ ($json.valor ?? 0).toString() }}. Em logs, serialize com {{ JSON.stringify($json, null, 2) }}; em prompts, prefira .toJsonString() quando disponível para saída compacta. Esses padrões evitam o clássico undefined nas execuções.
Os erros mais comuns e como ler a mensagem de erro

Erros falam muito: a mensagem já diz o tipo do problema e onde aconteceu. Olhe o nó, veja o trecho da expressão e confirme o caminho no preview. Com isso, você corrige mais rápido e evita repetir o erro.
Undefined e null: por que o campo não existe e como checar
Cheque o caminho: undefined e null surgem quando o path não existe no item atual. Se a chave tem espaço ou ponto, use bracket notation: {{ $json[‘nome completo’] }}. Se o dado está em um nó mais antigo, aponte pelo nome: {{ $(‘Set’).item.json.user.id }}.
Use optional chaining e nullish coalescing: {{ $json.user?.id ?? ” }}. Se o preview mostrar undefined mas a execução tiver valor, reexecute o nó anterior para atualizar o editor. Em mudanças de fluxo, verifique se “Keep Only Set Fields” não removeu o campo no Set/Edit Fields.
TypeError em arrays e objetos: índices, chaves e guard clauses
Ajuste índices corretos: TypeError aparece ao chamar método em undefined, como {{ $json.itens[0].sku.toLowerCase() }} quando itens está vazio. Guarde com {{ $json.itens?.[0]?.sku ?? ” }} antes de usar métodos.
Confirme o item pareado: após merges, prefira {{ $(‘Node’).first().json.campo }} quando o pareamento não é 1:1. Teste existência com {{ Array.isArray($json.itens) && $json.itens.length > 0 }}. Ao converter tipos, use {{ String($json.sku) }} e {{ Number($json.total) }} para evitar chamadas em tipos errados.
JSON vs string: quando parsear ou converter para evitar quebras
Parseie JSON certo: se a API retorna JSON como texto, faça {{ JSON.parse($json.payload).campo }}. Se vier com aspas literais, remova-as: {{ ($json.data ?? ”).replace(/”/g, ”) }} antes de usar.
Para datas que variam entre número, Date ou string, normalize primeiro: {{ new Date($json.modifyTime).toISOString().substring(0,10) }}. Com Luxon, prefira {{ DateTime.fromISO(String($json.createdAt)).toFormat(‘dd/MM/yyyy’) }}. Esse passo reduz erros silenciosos que viram null em nós como Edit Fields.
Debug prático: Execute Node, dados de teste e logs no painel de expressão
Execute Node para testar: rode o nó isolado e confira a saída anterior. Use o editor de expressão com pré-visualização, fixe dados de teste quando necessário e atualize a cadeia executando nós upstream.
No histórico, leia o primeiro parágrafo do erro: tipo, nó e trecho. Valide toggles como Keep Only Set Fields, verifique credenciais e formatos. Em casos intermitentes, filtre itens inválidos com Code ou ajuste o fluxo para garantir campos mínimos antes dos próximos passos.
Quando sair da expressão e usar o nó Code
Nem tudo precisa de código: expressões resolvem o básico com clareza. O nó Code entra quando a regra fica grande, repetível ou difícil de ler em uma linha.
Critérios de decisão: legibilidade, reuso, volume de dados e complexidade
Priorize nós nativos: use expressões, Set/Edit Fields, IF, Item Lists e Merge quando a lógica é simples e legível. Troque para Code se a regra exige várias etapas, reuso em pontos diferentes do fluxo ou condicionais intrincados.
Legibilidade pesa muito: se outra pessoa não entende a expressão em poucos segundos, mova para o Code e dê nome às funções. A comunidade relata overhead por execução no Code; nós nativos tendem a ser mais rápidos e previsíveis para operações comuns.
Casos ideais para Code: loops, validações, merges e mapeamentos complexos
Use Code para complexidade: loops customizados, validações entre vários campos, merges condicionais e mapeamentos aninhados cabem melhor em JavaScript claro do que em expressões longas.
Para lotes, processe com {{ $input.all().map((item, index) => ({ json: {/*…*/}, pairedItem: { item: index } })) }} e preserve o pairedItem. Em encadeamentos de APIs, quando Set não cobre o formato final, o Code cria o JSON exato sem gambiarras.
Do rascunho à função: transformar expressão em utilitário reutilizável
Comece na expressão, consolide no Code: rascunhe a lógica em {{ }} e, ao crescer, mova para o Code como função nomeada, com entradas claras e retorno padronizado.
Documente o que entra e o que sai, mantenha funções puras e pequenas e centralize o utilitário para reuso. Prefira ler dados apenas de $input/$json e devolver com a mesma estrutura, mantendo a compatibilidade do fluxo.
Boas práticas de manutenção e performance em pipelines extensos
Evite referenciar nós no Code: dentro do Code, não use {{ $(‘Node’) }} ou {{ $node[‘Node’] }}. Isso faz o runner buscar o workflow inteiro e pode travar. Passe valores antes com Set (expressões em nós nativos) e leia de $input no Code.
Escolha o modo certo: Run Once for All Items para agregações e Run Once for Each Item para transformar item a item. Não use “First Item” salvo exceções. Faça poda de dados cedo, evite JSON.stringify($input.all()) em cargas grandes, processe em lotes menores e adicione contador de segurança em loops para evitar travas.
Undefined
Se tem um vilão aqui, é o “undefined”: ele aparece quando o caminho não existe, o índice não bate ou o tipo não é o esperado. Você viu como contornar isso com referências seguras ($json e nome do nó), optional chaining e coalescência nula, além de boas práticas de preview e leitura da mensagem de erro. Para fechar a conta, use expressões para o simples, nó Code para o complexo e mantenha o fluxo limpo com Set, IF, Merge e testes curtos.
Quer cortar “undefined” do seu dia a dia? Agende um diagnóstico de 60 minutos com a Mistura Tech para mapear pontos frágeis, padronizar expressões, criar validações automáticas e definir quando migrar para o nó Code. Saia com um playbook claro e ajustado ao seu workflow.
Fluxos robustos nascem de referências estáveis, formatações previsíveis e depuração disciplinada; código só entra quando a complexidade realmente exige.
Perguntas frequentes
01O que são expressões no n8n?
São trechos entre {{ }} que executam JavaScript simples para ler e transformar dados durante a execução. Funcionam em campos de nós, com pré-visualização, e usam variáveis como $json (item atual), $(‘Nome do Nó’) e $node[“Nome do Nó”], além de $input para múltiplos itens.
02Como pegar o valor de outro nó no n8n?
Use $(‘Nome do Nó’).first().json.campo ou $node[“Nome do Nó”].json.campo. Arraste o caminho pelo Item Browser para evitar erro de digitação. Respeite maiúsculas/minúsculas do nome do nó. Em listas, use .all()[i] ou preserve pairedItem para manter o pareamento.
03Como formatar data no n8n?
Use Luxon nas expressões: $now.toFormat(‘dd/MM/yyyy’) ou DateTime.fromISO($json.createdAt).setZone(‘America/Sao_Paulo’).toFormat(‘HH:mm’). Com JavaScript nativo, use new Date($json.timestamp) e Intl.DateTimeFormat(‘pt-BR’, { dateStyle: ‘short’ }).format(…).
04Qual a diferença entre expressão e nó Code no n8n?
Expressões são curtas e ideais para puxar e formatar valores diretamente nos campos. O nó Code permite JavaScript completo para lógicas complexas, loops, validações e merges. Priorize nós nativos (Set, IF, Item Lists, Merge) pela legibilidade e manutenção; use Code quando não houver solução limpa com nós/expressões.
05Por que minha expressão retorna undefined no n8n?
Geralmente o caminho não existe no item atual, o campo foi removido por Set/Edit Fields, ou há múltiplos itens. Corrija com bracket notation para chaves com espaço, referencie pelo nome do nó, e use .first()/.all()[i] quando houver várias saídas. Reexecute o nó anterior para atualizar o preview e use ?. e ?? para evitar quebras.
Referências Externas

Rodrigo Monteiro
Fundador da Mistura Tech. Mais de 26 anos de experiência em TI, hoje com foco em IA e automações para empresas: treinamento de equipes, agentes no WhatsApp e integrações com N8N.


