Expressões e variáveis

Expressões são pequenas fórmulas que deixam seus campos dinâmicos: em vez de um texto fixo, o valor é calculado na hora, com base no que o usuário digitou, em parâmetros da URL ou nos dados do usuário logado.

Se você já usou fórmulas no Excel, a ideia é a mesma — só que a "célula" aqui é outro componente da sua página.

Sintaxe básica

Tudo que estiver entre chaves duplas {{ ... }} é avaliado como expressão. O resto do texto fica literal:

Olá, {{ $form.Nome }}! Seja bem-vindo.

Se o campo Nome contém "Maria", o resultado é:

Olá, Maria! Seja bem-vindo.

Você pode misturar quanto texto e quantas expressões quiser na mesma frase:

Total: {{ $form.Quantidade * $form.Preco }} reais

Se Quantidade for 3 e Preço for 10, o resultado é:

Total: 30 reais

Onde você pode usar expressões

O campo de expressão aparece em vários lugares do editor:

No campo "Expressão" de um componente (aba Config) — o resultado vira o valor exibido daquele componente. É assim que se cria um "campo calculado" ou um texto que se atualiza sozinho.
No valor padrão de um campo.
Nos campos de uma automação — URL, cabeçalhos e corpo de uma requisição HTTP, por exemplo, aceitam {{ }}.
Na consulta SQL de um componente de banco de dados — cada {{ }} vira um parâmetro seguro da consulta. Veja Banco de dados (SQL).

Variáveis disponíveis

Uma variável sempre começa com $ e tem o formato $origem.chave. Existem quatro origens:

`$form` — valores da própria página

Referencia o valor de outro componente da página. Use o rótulo (o nome que aparece no componente):

{{ $form.Nome_do_Cliente }}

Rótulos com espaço, acento ou hífen

No formato com ponto, espaços viram sublinhado (Nome do Cliente → Nome_do_Cliente) e acentos funcionam normalmente ({{ $form.Usuário }}).

Mas hífens (-) atrapalham, porque o - é o sinal de subtração. Para rótulos com hífen, espaço ou qualquer caractere especial, use colchetes com aspas:

{{ $form["Terça-feira"] }}
{{ $form["Data de Nascimento"] }}

Além do valor simples, o $form consegue "entrar" em dados estruturados:

Coluna de uma tabela (componente de banco/HTTP — a linha selecionada ou, se a tabela é somente leitura, a primeira linha do resultado):
```
{{ $form.Tabela_de_Produtos.nome }}
```
Célula de uma planilha (endereço no estilo A1):
```
{{ $form.Minha_Planilha.B2 }}
```

`$data` — resultados de consultas

Tudo o que uma Consulta ao banco, uma Requisição HTTP ou uma Planilha (primeira aba) da página retornou, como tabela. Funciona como numa planilha: uma coluna é uma lista inteira, uma linha é uma linha.

Expressão	O que retorna
`$data.Vendas`	A tabela inteira (`{ columns, rows }`)
`$data.Vendas.total`	A coluna `total` inteira (uma lista)
`$data.Vendas.total.1`	Uma célula: primeira linha da coluna `total` (1-based)
`ROW($data.Vendas, 1)`	A primeira linha inteira (objeto `{ coluna: valor }`)

A consulta pode ser referida pelo id ou pelo rótulo, como em $form. Uma consulta que retorna um único valor é só uma tabela 1×1: use $data.Total.valor.1 ou FIRST($data.Total.valor).

$data × $form numa consulta

$form.Vendas é o que o usuário selecionou (numa consulta selecionável) ou a primeira linha (numa consulta somente leitura). $data.Vendas é sempre o resultado completo, antes de qualquer clique.

Listas e tabelas viram JSON quando aparecem como texto ({{ $data.Vendas.total }} mostra [10,20,30]). Em corpos de automação sem aspas elas entram como JSON de verdade: "ids": {{ $data.Vendas.id }} → "ids": [1,2,3].

Detalhes que costumam surpreender

Uma lista não entra em contas: {{ $data.Vendas.total + 1 }} junta texto. Use .1, FIRST() ou SUM() para obter um número.
Uma lista vazia conta como falso: IF($data.Vendas.total, "tem", "vazio").
Com rótulo entre colchetes só dá para pegar a tabela inteira: COL($data["Minha Consulta"], "total") ou INDEX(COL(...), 1).
SUM/AVG/MIN/MAX ignoram textos que não são números, inclusive 1,5 com vírgula decimal — converta no SQL.

`$args` — parâmetros da URL

Qualquer valor passado na URL do link público vira uma variável $args. Por exemplo, ao abrir:

/p/SEU_TOKEN?cliente=Acme&plano=premium

você pode usar:

{{ $args.cliente }}   →  Acme
{{ $args.plano }}     →  premium

Ótimo para pré-preencher um workflow a partir de um link personalizado.

`$user` — dados do usuário logado

Disponível apenas quando o workflow exige login. Traz informações do perfil de quem está usando:

Variável	O que contém
`$user.name`	Nome do usuário
`$user.username`	Login/usuário
`$user.playerId`	ID do player
`$user.personId`	ID da pessoa
`$user.tenantId`	ID do tenant (empresa)
`$user.workgroupNames`	Nomes dos workgroups (separados por vírgula)
`$user.workgroupIds`	IDs dos workgroups
`$user.firstWorkgroupName`	Nome do primeiro workgroup
`$user.firstWorkgroupId`	ID do primeiro workgroup

observação

Se o workflow não exige login, todas as variáveis $user ficam vazias.

Operadores

Tipo	Operadores	Exemplo
Aritméticos	`+` `-` `*` `/` `%`	`{{ $form.Preco * 2 }}`
Comparação	`==` `!=` `>` `<` `>=` `<=`	`{{ $form.Idade >= 18 }}`
Lógicos	`&&` (e) `\|\|` (ou) `!` (não)	`{{ $form.Ativo && $form.Pago }}`
Condicional	`condição ? valorSeVerdadeiro : valorSeFalso`	`{{ $form.Idade >= 18 ? "Maior" : "Menor" }}`

Você pode agrupar com parênteses para controlar a ordem:

{{ ($form.A + $form.B) * $form.C }}

O operador + soma OU concatena

Se os dois lados forem números, o + soma. Se algum lado for texto, ele junta (concatena):

{{ 2 + 3 }}                    →  5
{{ $form.Nome + " Silva" }}    →  Maria Silva

Para garantir uma soma, certifique-se de que os dois campos são numéricos.

Detalhes que evitam surpresas

Comparações == e != comparam como texto: 1 == "1" é verdadeiro.
Divisão ou resto por zero retorna 0 (não dá erro nem "infinito").
> < >= <= comparam como número.

Funções

As funções não diferenciam maiúsculas de minúsculas (IF e if funcionam igual).

Função	O que faz	Exemplo	Resultado
`IF(cond, a, b)`	Retorna `a` se a condição for verdadeira, senão `b`	`IF($form.Idade >= 18, "OK", "Bloqueado")`	`OK`
`UPPER(texto)`	Converte para MAIÚSCULAS	`UPPER("maria")`	`MARIA`
`LOWER(texto)`	Converte para minúsculas	`LOWER("MARIA")`	`maria`
`LEN(texto)`	Conta os caracteres	`LEN("abc")`	`3`
`ABS(número)`	Valor absoluto (sem sinal)	`ABS(-7)`	`7`
`ROUND(número, casas)`	Arredonda para N casas decimais (padrão 0)	`ROUND(3.14159, 2)`	`3.14`
`CONCAT(a, b, ...)`	Junta vários valores como texto	`CONCAT($form.Nome, " - ", $form.Cidade)`	`Maria - Recife`
`NOW()`	Data/hora atual	`NOW()`	`1719856800000`
`SUM(lista)`	Soma os números da lista (ignora vazios e textos)	`SUM($data.Vendas.total)`	`1250`
`AVG(lista)`	Média dos números	`AVG($data.Vendas.total)`	`416.67`
`MIN(lista)` / `MAX(lista)`	Menor / maior número	`MAX($data.Vendas.total)`	`800`
`COUNT(tabela ou lista)`	Quantidade de linhas (tabela) ou de itens (lista)	`COUNT($data.Vendas)`	`3`
`JOIN(lista, separador)`	Junta os itens como texto	`JOIN($data.Clientes.nome, ", ")`	`Ana, Bia`
`FIRST(lista)` / `LAST(lista)`	Primeiro / último item	`FIRST($data.Vendas.mes)`	`Jan`
`INDEX(lista, n)`	O n-ésimo item (1-based)	`INDEX($data.Vendas.mes, 2)`	`Fev`
`ROW(tabela, n)`	A n-ésima linha como objeto	`ROW($data.Vendas, 1)`	`{"mes":"Jan","total":450}`
`COL(tabela, "coluna")`	Uma coluna pelo nome	`COL($data.Vendas, "total")`	`[450,800,0]`

NOW retorna um número, não uma data

NOW() retorna o instante atual em milissegundos (um número grande), e não uma data formatada como 01/07/2026. Por enquanto não há função de formatação de data no editor — use NOW() para comparar ou calcular tempos, não para exibir uma data bonita.

Recálculo automático

Um campo com expressão se atualiza sozinho sempre que um dos campos que ele referencia muda. Se o Preço ou a Quantidade mudam, um campo Total com a expressão {{ $form.Preco * $form.Quantidade }} recalcula na hora.

Referências circulares

Se o campo A depende do B e o B depende do A, o editor detecta esse "laço" e simplesmente ignora o recálculo, em vez de travar. Evite montar dependências circulares.

Componentes de banco de dados são uma exceção

Diferente dos campos comuns, um componente de banco de dados roda sua consulta uma única vez, no momento em que a página abre — ele não recalcula quando um campo muda. Na prática:

Não dá para usar um campo da mesma página como filtro digitável: como a consulta roda assim que a página abre, um campo que o usuário ainda vai preencher ali estará vazio — e a consulta não recebe o valor. Para alimentar a consulta, use um $args (parâmetro da URL), um valor padrão ou um valor vindo de uma página anterior.
Dentro do SQL, as expressões {{ }} funcionam normalmente ({{ $form.Campo }}, {{ $args.id }}, funções etc.) — e o formato antigo $Campo continua valendo. Detalhes em Banco de dados (SQL).

Erros comuns (leia antes de pedir ajuda 😉)

Esqueceu o prefixo $form

Escrever {{ Nome }} não pega o valor do campo Nome — o editor trata palavras soltas como texto literal e o resultado vira a própria palavra "Nome". O certo é sempre {{ $form.Nome }}.

Um erro de sintaxe esvazia a expressão

Se uma expressão tem um erro (um parêntese que não fecha, aspas faltando, etc.), aquele {{ }} fica vazio — o resto do texto permanece e não aparece mensagem de erro na tela. Se um trecho "sumiu", quase sempre é uma expressão quebrada. Revise as chaves, parênteses e aspas.

Referência que não existe (campo apagado ou nome errado) resulta em texto vazio, não em erro.
Chaves simples não funcionam: é sempre {{ }} (duplas), nunca { }.

Exemplos prontos para copiar

Saudação personalizada:

Olá, {{ $form.Nome }}! Que bom te ver.

Total de um pedido:

{{ $form.Quantidade * $form.Preco_Unitario }}

Mensagem condicional:

{{ $form.Idade >= 18 ? "Acesso liberado" : "Acesso apenas para maiores de 18" }}

Juntar nome e sobrenome em maiúsculas:

{{ UPPER(CONCAT($form.Nome, " ", $form.Sobrenome)) }}

Usar um dado da URL como padrão:

{{ $args.cliente }}

KPI com o total de uma consulta:

Total: {{ SUM($data.Vendas.total) }}

Lista de nomes de uma consulta:

{{ JOIN($data.Clientes.nome, ", ") }}

Um único valor de uma consulta:

{{ $data.Resumo.faturamento.1 }}

Lista de ids no corpo de uma automação (sem aspas vira JSON):

{ "ids": {{ $data.Vendas.id }} }

Consultas com $data nos parâmetros

As consultas de uma página rodam juntas ao abrir e não rodam de novo quando outra consulta responde. Por isso, $data dentro de um parâmetro SQL só funciona para consultas de páginas seguintes (ou na pré-visualização do editor, que roda uma por vez).

Sintaxe básica​

Onde você pode usar expressões​

Variáveis disponíveis​

$form — valores da própria página​

$data — resultados de consultas​

$args — parâmetros da URL​

$user — dados do usuário logado​

Operadores​

Funções​

Recálculo automático​

Erros comuns (leia antes de pedir ajuda 😉)​

Exemplos prontos para copiar​