Funções do Power Automate: guia de referência completo

Todo fluxo de Power Automate que cresce sem controle tem o mesmo sintoma: uma sequência de ações de “Inicializar variável”, “Definir variável” e “Condição” que poderia ter sido resolvida em uma única expressão. O motivo quase sempre é o mesmo: quem monta o fluxo não sabe que a função existe, ou não lembra da sintaxe exata na hora de escrever.

O Power Automate usa a Workflow Definition Language, a mesma linguagem de expressões dos Azure Logic Apps, para tudo que não é uma ação de conector. Ela tem mais de 140 funções distribuídas em nove categorias, todas documentadas pela Microsoft, mas espalhadas em uma única página longa, sem categorização fácil de escanear. Este guia organiza essas funções por finalidade, com sintaxe e link direto para a referência oficial, para consulta rápida enquanto você edita uma expressão no fluxo.

Por que escrever expressões em vez de empilhar ações

Cada ação adicionada a um fluxo tem custo. Custo de execução (mais chamadas, mais tempo, mais chance de throttling em conectores premium), custo de manutenção (mais passos para outra pessoa entender) e custo de licenciamento em cenários onde a ação dispara uma chamada a um conector premium desnecessário. Uma expressão bem escrita substitui, com frequência, três ou quatro ações por uma única linha dentro de um campo já existente.

Um exemplo comum: extrair o domínio de um e-mail. A abordagem por ações usa split em uma ação de composição, depois um índice, depois outra composição para montar o resultado. A abordagem por expressão resolve em uma linha:

split(triggerBody()?['Email'], '@')[1]

Isso não significa que expressão é sempre superior a ação. Fluxos muito densos em expressões aninhadas ficam ilegíveis para quem não domina a sintaxe, e depurar uma expressão longa dentro do editor do Power Automate é mais difícil do que inspecionar a saída de várias ações pequenas no histórico de execução. A recomendação prática é usar expressão para transformações pontuais de dado (formatar, extrair, comparar, converter) e manter ações separadas para passos que representam uma decisão de negócio relevante, algo que alguém vai querer localizar rápido ao revisar o fluxo.

Onde escrever a expressão

O editor de expressões fica disponível em qualquer campo dinâmico do fluxo, acessível pelo ícone de raio ou digitando diretamente entre chaves. No modo texto do fluxo (Editar em modo avançado, disponível ao exportar o fluxo como código ou usar o editor do Power Automate for desktop e do Copilot Studio), a sintaxe segue o padrão @{funcao(parametros)}. Dentro do editor visual padrão, basta digitar o nome da função e o Intellisense sugere os parâmetros esperados.

A documentação oficial completa da Workflow Definition Language, com todas as funções, parâmetros e exemplos atualizados pela Microsoft, está na referência de funções para expressões no Azure Logic Apps e Power Automate. As tabelas abaixo linkam direto para a seção correspondente dessa página.

Funções de texto

Manipulam strings: recorte, concatenação, busca de substring, mudança de caixa. São as mais usadas em fluxos que tratam entrada de formulário, e-mail ou arquivo, onde o dado raramente chega já formatado do jeito que o próximo passo espera.

Função	O que faz	Sintaxe
chunk	Divide uma string ou coleção em blocos de tamanho igual	`chunk(collection, length)`
concat	Junta duas ou mais strings em uma só	`concat(text1, text2, ...)`
endsWith	Verifica se a string termina com o texto informado	`endsWith(text, searchText)`
formatNumber	Converte um número em string usando um formato específico	`formatNumber(number, format, locale)`
guid	Gera um identificador único global (GUID) como string	`guid(format)`
indexOf	Retorna a posição inicial de uma substring	`indexOf(text, searchText)`
isFloat	Verifica se uma string representa um número decimal	`isFloat(value, locale)`
isInt	Verifica se uma string representa um número inteiro	`isInt(string)`
lastIndexOf	Retorna a posição da última ocorrência de uma substring	`lastIndexOf(text, searchText)`
length	Conta os caracteres de uma string ou itens de uma coleção	`length(collection)`
nthIndexOf	Retorna a posição da n-ésima ocorrência de uma substring	`nthIndexOf(text, searchText, occurrence)`
replace	Substitui uma substring por outra dentro do texto	`replace(text, oldText, newText)`
slice	Retorna um trecho de texto entre duas posições	`slice(text, startIndex, endIndex)`
split	Divide o texto em um array a partir de um delimitador	`split(text, delimiter)`
startsWith	Verifica se a string começa com o texto informado	`startsWith(text, searchText)`
substring	Retorna caracteres a partir de uma posição, com tamanho definido	`substring(text, startIndex, length)`
toLower	Converte o texto para minúsculas	`toLower(text)`
toUpper	Converte o texto para maiúsculas	`toUpper(text)`
trim	Remove espaços em branco no início e no fim do texto	`trim(text)`

Uma pegadinha frequente com substring e slice: os índices são baseados em zero e um valor de início maior que o comprimento da string gera erro em tempo de execução, não retorna vazio. Se o dado de origem pode variar de tamanho (nome de arquivo, e-mail sem domínio), combine com length dentro de uma verificação antes de fatiar, ou use if para tratar o caso em que a string é mais curta que o esperado.

Funções de coleção

Atuam sobre arrays: filtrar, ordenar, combinar, dividir. Ganham relevância em fluxos que processam listas do SharePoint, resultados de uma consulta ao Dataverse ou arrays retornados por uma chamada HTTP a uma API externa.

Função	O que faz	Sintaxe
chunk	Divide uma coleção em partes de tamanho igual	`chunk(collection, length)`
contains	Verifica se a coleção contém determinado item	`contains(collection, value)`
empty	Verifica se a coleção está vazia	`empty(collection)`
first	Retorna o primeiro item de uma coleção	`first(collection)`
intersection	Retorna os itens em comum entre as coleções informadas	`intersection(collection1, collection2, ...)`
item	Retorna o item atual dentro de um loop	`item()`
join	Concatena os itens de um array em uma string, com delimitador	`join(collection, delimiter)`
last	Retorna o último item de uma coleção	`last(collection)`
length	Conta os itens de um array	`length(collection)`
reverse	Inverte a ordem dos itens de um array	`reverse(collection)`
skip	Remove uma quantidade de itens do início e retorna o restante	`skip(collection, count)`
sort	Ordena os itens de uma coleção	`sort(collection, sortBy)`
take	Retorna os primeiros N itens de uma coleção	`take(collection, count)`
union	Combina os itens de múltiplas coleções, removendo duplicados	`union(collection1, collection2, ...)`

Uma decisão de arquitetura relevante aqui: filter como ação nativa do Power Automate já resolve boa parte do que se tentaria fazer combinando contains e intersection em expressão. Quando o filtro depende de uma condição simples sobre um array vindo de uma ação anterior, use a ação Filtrar array, que gera um log de execução legível. Reserve as funções de coleção em expressão para transformações que a ação nativa não cobre, como cruzar dois arrays de origens diferentes.

Funções de comparação lógica

Constroem a lógica condicional que, de outra forma, exigiria várias ações de Condição aninhadas. São a base de qualquer expressão dentro de um campo de “Condição” configurado em modo avançado.

Função	O que faz	Sintaxe
and	Retorna verdadeiro se todas as expressões forem verdadeiras	`and(expression1, expression2, ...)`
equals	Verifica se dois valores são iguais	`equals(object1, object2)`
greater	Verifica se o primeiro valor é maior que o segundo	`greater(value, compareTo)`
greaterOrEquals	Verifica se o primeiro valor é maior ou igual ao segundo	`greaterOrEquals(value, compareTo)`
if	Retorna um valor ou outro conforme uma expressão booleana	`if(expression, valueIfTrue, valueIfFalse)`
isFloat	Verifica se uma string representa um decimal	`isFloat(value, locale)`
isInt	Verifica se uma string representa um inteiro	`isInt(string)`
less	Verifica se o primeiro valor é menor que o segundo	`less(value, compareTo)`
lessOrEquals	Verifica se o primeiro valor é menor ou igual ao segundo	`lessOrEquals(value, compareTo)`
not	Inverte o resultado de uma expressão booleana	`not(expression)`
or	Retorna verdadeiro se pelo menos uma expressão for verdadeira	`or(expression1, expression2, ...)`

if aninhado substitui bem uma cadeia de Condições quando o resultado é um valor simples (texto, número, booleano) a ser usado em outro campo. Quando o resultado de cada ramificação é uma sequência de ações diferentes, mantenha a ação Condição nativa: aninhar mais de dois ou três níveis de if numa única expressão produz uma string difícil de revisar e praticamente impossível de depurar a olho nu.

Funções de conversão

Convertem entre tipos e formatos: texto, número, binário, base64, URI, JSON, XML. Essenciais em qualquer fluxo que troca dado com uma API REST, processa anexos ou lê arquivo.

Função	O que faz	Sintaxe
array	Converte um valor único em array	`array(value)`
base64	Codifica uma string em base64	`base64(value)`
base64ToBinary	Converte uma string base64 em binário	`base64ToBinary(value)`
base64ToString	Converte uma string base64 em texto plano	`base64ToString(value)`
binary	Converte um valor em representação binária	`binary(value)`
bool	Converte um valor em booleano	`bool(value)`
createArray	Cria um array a partir dos valores informados	`createArray(object1, object2, ...)`
dataUri	Retorna o URI de dados de um valor	`dataUri(value)`
dataUriToBinary	Converte um URI de dados em binário	`dataUriToBinary(value)`
dataUriToString	Converte um URI de dados em texto plano	`dataUriToString(value)`
decimal	Converte uma string decimal em número decimal	`decimal(value)`
decodeBase64	Decodifica uma string base64 em texto plano	`decodeBase64(value)`
decodeDataUri	Converte um URI de dados em binário	`decodeDataUri(value)`
decodeUriComponent	Decodifica um componente de URI	`decodeUriComponent(value)`
encodeUriComponent	Codifica um valor como componente de URI	`encodeUriComponent(value)`
float	Converte um valor em número de ponto flutuante	`float(value)`
int	Converte uma string em número inteiro	`int(value)`
json	Interpreta uma string ou XML como JSON	`json(value)`
string	Converte um valor em string	`string(value)`
uriComponent	Codifica um valor como componente de URI	`uriComponent(value)`
uriComponentToBinary	Converte um componente de URI em binário	`uriComponentToBinary(value)`
uriComponentToString	Converte um componente de URI em texto plano	`uriComponentToString(value)`
xml	Converte uma string em XML	`xml(value)`

A função json merece atenção especial: é o caminho mais direto para parsear a resposta de uma chamada HTTP sem precisar de uma ação separada de Analisar JSON. A troca é que, sem o schema declarado que a ação Analisar JSON exige, o Intellisense não sugere as propriedades internas, e você precisa conhecer a estrutura do payload de antemão ou consultar a documentação da API de origem.

Funções matemáticas

Operações aritméticas básicas e geração de intervalos numéricos. Curtas, mas frequentes em cálculo de paginação, distribuição de carga entre lotes e geração de índices para loops.

Função	O que faz	Sintaxe
add	Soma dois números	`add(number1, number2)`
div	Divide dois números	`div(dividend, divisor)`
max	Retorna o maior valor de um conjunto ou array	`max(number1, number2, ...)`
min	Retorna o menor valor de um conjunto ou array	`min(number1, number2, ...)`
mod	Retorna o resto de uma divisão	`mod(dividend, divisor)`
mul	Multiplica dois números	`mul(number1, number2)`
rand	Gera um número inteiro aleatório dentro de um intervalo	`rand(minValue, maxValue)`
range	Cria um array de inteiros a partir de um número inicial	`range(startIndex, count)`
sub	Subtrai dois números	`sub(number1, number2)`

Funções de data e hora

São, na prática, a categoria com mais chance de erro silencioso em produção, porque o Power Automate trabalha internamente em UTC. Um fluxo que soma dias ou horas sem converter para o fuso do usuário final envia notificação no horário errado, e o erro só aparece quando alguém reclama, não durante o teste no editor.

Função	O que faz	Sintaxe
addDays	Adiciona dias a um timestamp	`addDays(timestamp, days, format)`
addHours	Adiciona horas a um timestamp	`addHours(timestamp, hours, format)`
addMinutes	Adiciona minutos a um timestamp	`addMinutes(timestamp, minutes, format)`
addSeconds	Adiciona segundos a um timestamp	`addSeconds(timestamp, seconds, format)`
addToTime	Adiciona uma unidade de tempo específica a um timestamp	`addToTime(timestamp, interval, timeUnit, format)`
convertFromUtc	Converte um timestamp UTC para o fuso de destino	`convertFromUtc(timestamp, destinationTimeZone, format)`
convertTimeZone	Converte um timestamp entre dois fusos horários	`convertTimeZone(timestamp, sourceTimeZone, destinationTimeZone, format)`
convertToUtc	Converte um timestamp de um fuso local para UTC	`convertToUtc(timestamp, sourceTimeZone, format)`
dayOfMonth	Retorna o dia do mês de um timestamp	`dayOfMonth(timestamp)`
dayOfWeek	Retorna o dia da semana de um timestamp	`dayOfWeek(timestamp)`
dayOfYear	Retorna o dia do ano de um timestamp	`dayOfYear(timestamp)`
formatDateTime	Formata um timestamp conforme o padrão informado	`formatDateTime(timestamp, format, locale)`
getFutureTime	Retorna a hora atual mais um intervalo de tempo	`getFutureTime(interval, timeUnit, format)`
getPastTime	Retorna a hora atual menos um intervalo de tempo	`getPastTime(interval, timeUnit, format)`
parseDateTime	Converte uma string em timestamp	`parseDateTime(timestamp, locale, format)`
startOfDay	Retorna o início do dia de um timestamp	`startOfDay(timestamp, format)`
startOfHour	Retorna o início da hora de um timestamp	`startOfHour(timestamp, format)`
startOfMonth	Retorna o início do mês de um timestamp	`startOfMonth(timestamp, format)`
subtractFromTime	Subtrai uma unidade de tempo de um timestamp	`subtractFromTime(timestamp, interval, timeUnit, format)`
ticks	Retorna o valor em ticks de um timestamp	`ticks(timestamp)`
utcNow	Retorna o timestamp atual em UTC	`utcNow(format)`

A dupla convertFromUtc e convertTimeZone resolve o problema de fuso, mas exige o nome exato do fuso horário no formato aceito pelo Windows (por exemplo, E. South America Standard Time para o horário de Brasília), não o nome IANA usado em outras plataformas. Errar essa string não gera erro de sintaxe, gera conversão silenciosamente incorreta, porque a função ignora fuso não reconhecido e mantém UTC.

Funções de workflow

Acessam o contexto de execução do próprio fluxo: saída de uma ação anterior, corpo do gatilho, valor de uma variável, índice de iteração dentro de um loop. São a categoria mais usada, ainda que de forma invisível, porque o editor do Power Automate gera boa parte dessas expressões automaticamente quando você seleciona um conteúdo dinâmico na interface.

Função	O que faz	Sintaxe
action	Retorna a saída da ação atual	`action().property`
actionBody	Retorna o corpo da saída de uma ação específica	`actionBody('actionName')`
actionOutputs	Retorna a saída de uma ação em tempo de execução	`actionOutputs('actionName')`
actions	Retorna a saída de uma ação ou um par nome-valor do JSON	`actions('actionName').property`
body	Retorna o corpo de saída de uma ação	`body('actionName')`
formDataMultiValues	Cria um array com os valores correspondentes a uma chave	`formDataMultiValues('actionName', 'key')`
formDataValue	Retorna o valor correspondente a uma chave	`formDataValue('actionName', 'key')`
item	Retorna o item atual em um loop Apply to each	`item()`
items	Retorna o item atual em um loop nomeado	`items('loopName')`
iterationIndexes	Retorna o índice atual dentro de um loop Until	`iterationIndexes('loopName')`
listCallbackUrl	Retorna a URL de callback de um gatilho ou ação	`listCallbackUrl()`
multipartBody	Retorna o corpo de uma parte de uma saída multipart	`multipartBody('actionName', index)`
outputs	Retorna a saída completa de uma ação	`outputs('actionName')`
parameters	Retorna o valor de um parâmetro do fluxo	`parameters('parameterName')`
result	Retorna entradas e saídas de uma ação com escopo	`result('scopedActionName')`
trigger	Retorna a saída do gatilho do fluxo	`trigger().property`
triggerBody	Retorna o corpo de saída do gatilho	`triggerBody()`
triggerFormDataValue	Retorna o valor de uma chave nas saídas do gatilho	`triggerFormDataValue('key')`
triggerFormDataMultiValues	Cria um array com os valores de uma chave do gatilho	`triggerFormDataMultiValues('key')`
triggerMultipartBody	Retorna o corpo de uma parte da saída do gatilho	`triggerMultipartBody(index)`
triggerOutputs	Retorna a saída completa do gatilho	`triggerOutputs()`
variables	Retorna o valor de uma variável do fluxo	`variables('variableName')`
workflow	Retorna detalhes sobre o próprio fluxo	`workflow().property`

A diferença entre body('actionName') e outputs('actionName') confunde bastante gente: body retorna só a propriedade body da saída da ação, outputs retorna a saída inteira, incluindo cabeçalhos e status code de uma chamada HTTP, por exemplo. Se você precisa validar o status de uma resposta HTTP antes de seguir, é outputs, não body, que traz essa informação.

Funções de parsing de URI

Quebram uma URI em seus componentes. Usadas com frequência em fluxos que recebem um link (de um item do SharePoint, de um e-mail, de um webhook) e precisam extrair só uma parte dele, como o host para validação de domínio ou a query string para ler parâmetros.

Função	O que faz	Sintaxe
uriHost	Retorna o host de uma URI	`uriHost(uri)`
uriPath	Retorna o caminho de uma URI	`uriPath(uri)`
uriPathAndQuery	Retorna caminho e query string de uma URI	`uriPathAndQuery(uri)`
uriPort	Retorna a porta de uma URI	`uriPort(uri)`
uriQuery	Retorna a query string de uma URI	`uriQuery(uri)`
uriScheme	Retorna o esquema (http, https) de uma URI	`uriScheme(uri)`

Funções de manipulação de JSON e XML

Editam objetos JSON e navegam em XML sem precisar reconstruir o objeto inteiro em uma ação separada. Particularmente úteis quando o fluxo precisa enriquecer um payload antes de enviá-lo a uma API, adicionando ou removendo uma propriedade pontual.

Função	O que faz	Sintaxe
addProperty	Adiciona uma propriedade e seu valor a um objeto JSON	`addProperty(object, property, value)`
coalesce	Retorna o primeiro valor não nulo entre os parâmetros informados	`coalesce(value1, value2, ...)`
removeProperty	Remove uma propriedade de um objeto JSON	`removeProperty(object, property)`
setProperty	Define o valor de uma propriedade em um objeto JSON	`setProperty(object, property, value)`
xpath	Retorna nós ou valores que correspondem a um XPath	`xpath(xml, path)`

coalesce resolve um padrão que, sem ela, vira uma torre de if aninhado: pegar o primeiro valor preenchido entre vários campos opcionais de um formulário. Em vez de if(empty(campoA), if(empty(campoB), campoC, campoB), campoA), a expressão fica coalesce(campoA, campoB, campoC), mais curta e muito mais fácil de auditar depois.

Como usar esta referência no dia a dia

Nenhuma equipe de automação memoriza 140 funções. O ganho real de ter essa lista organizada por categoria é outro: quando você sente que uma transformação está exigindo ações demais, a primeira pergunta vira “existe uma função para isso” em vez de “que ação eu adiciono agora”. Isso muda o hábito de construção do fluxo, e fluxos construídos com esse hábito tendem a ter menos ações, menos pontos de falha e menos consumo desnecessário de conectores premium.

Vale também documentar, dentro do próprio fluxo, expressões que combinam três ou mais funções aninhadas. Um comentário na ação, ou um nome descritivo na variável que recebe o resultado, economiza tempo de quem vai dar manutenção seis meses depois e não tem a lógica da expressão fresca na cabeça.

Se o seu fluxo já cresceu a ponto de virar um emaranhado de condições e variáveis, ou se a dúvida é sobre onde a lógica de negócio deveria morar (no fluxo, num conector customizado, num Power Automate Desktop, numa Function do Azure), essa é uma conversa de arquitetura que vale a pena ter antes de continuar empilhando ações.