# Me Ajuda Flow: conteúdo completo

Fonte: https://meajudaflow.com.br. Uso livre, desde que cite a fonte com link: Me Ajuda Flow (https://meajudaflow.com.br).

# Guias

## Sua primeira expressão no Power Automate

URL: https://meajudaflow.com.br/guias/primeira-expressao-power-automate
Atualizado em: 2026-11-02

Expressões transformam dados dentro do fluxo: juntam textos, decidem entre dois valores, tratam campos vazios e formatam datas. Este guia explica a estrutura, mostra os exemplos que você mais vai usar e ensina a testar sem medo.

## O que é uma expressão

Uma expressão é uma instrução que o Power Automate calcula durante a execução do fluxo. Em vez de usar sempre um valor fixo, você monta o resultado a partir dos dados que chegaram: o nome de quem preencheu um formulário, o status de um item, a data de hoje.

Toda expressão é feita de funções (concat, if, utcNow), de valores (textos entre aspas simples, números) e de referências a dados do fluxo (triggerBody(), body('Nome_da_ação')).

## Onde digitar

- Clique no campo de uma ação em que você quer usar a expressão.
- No painel que abre, escolha a aba Expressão (ícone fx), em vez de Conteúdo dinâmico.

- Cole ou digite a expressão sem o @ do começo e confirme com OK.

Antes de colar, você pode conferir a sua expressão no verificador (https://meajudaflow.com.br/tools/power-automate): ele aponta aspas e parênteses errados e sugere o nome certo de uma função.

## As quatro regras de sintaxe que evitam 90% dos erros

- Texto fica entre aspas simples: 'Aprovado'. Aspas duplas dão erro. Uma aspa simples dentro do texto se escreve duas vezes: 'it''s'.
- Funções usam parênteses e vírgulas: nomeDaFuncao(argumento1, argumento2). Cada parêntese aberto precisa de um fechado.

- O ? antes do colchete é um acesso seguro: triggerBody()?['nome'] devolve vazio se o campo não existir, em vez de derrubar o fluxo.
- Funções podem ser aninhadas: o resultado de uma serve de argumento para outra, e a conta é feita de dentro para fora.

## Exemplo 1: juntar textos

```
concat('Olá, ', triggerBody()?['nome'])
```

concat junta textos. triggerBody()?['nome'] lê a propriedade nome do que disparou o fluxo. Se o nome for "Ana", o resultado é Olá, Ana.

## Exemplo 2: decidir entre dois valores

```
if(equals(triggerBody()?['status'], 'Aprovado'), 'Sim', 'Não')
```

Primeiro o equals compara dois valores e devolve verdadeiro ou falso. Depois o if escolhe o segundo argumento (quando verdadeiro) ou o terceiro (quando falso).

## Exemplo 3: lidar com campo vazio

Campos opcionais chegam vazios com frequência. Duas funções resolvem:

```
coalesce(triggerBody()?['apelido'], triggerBody()?['nome'], 'Cliente')
```

coalesce devolve o primeiro valor que não for nulo. Aqui: o apelido, se existir; senão o nome; senão a palavra "Cliente".

```
if(empty(triggerBody()?['observacao']), 'Sem observação', triggerBody()?['observacao'])
```

empty diz se o texto, a lista ou o objeto está vazio. Um texto vazio e um valor nulo são coisas diferentes para o fluxo.

Cuidado com o coalesce: ele só pula valores nulos. Testado no Power Automate: coalesce('', 'x') devolve o texto vazio, e não o x. Se o apelido puder chegar como texto vazio, trate com empty:

```
if(empty(triggerBody()?['apelido']), triggerBody()?['nome'], triggerBody()?['apelido'])
```

## Exemplo 4: formatar datas

```
formatDateTime(utcNow(), 'dd/MM/yyyy HH:mm')
```

utcNow() devolve a data e a hora atuais em UTC, não no horário de Brasília. Para o horário local:

```
convertTimeZone(utcNow(), 'UTC', 'E. South America Standard Time', 'dd/MM/yyyy HH:mm')
```

Atenção às letras: no formato de data, MM maiúsculo é mês e mm minúsculo é minuto. HH é hora em 24 horas. Trocar maiúsculas por minúsculas é um dos erros mais comuns. Veja mais no conversor de datas (https://meajudaflow.com.br/tools/datas).

Testado: as expressões acima foram executadas em um fluxo de teste do Power Automate (sem conectores, sem dados reais) em 02/11/2026 e devolveram: Olá, Ana (concat), Sim (if com equals), Ana (coalesce com apelido nulo), Sem observação (empty), 02/11/2026 08:05:09 (formatDateTime) e 02/11/2026 08:30 (convertTimeZone de 11:30 UTC para Brasília). Veja a referência de funções (https://meajudaflow.com.br/referencia/).

## Funções que você vai usar toda semana

| Para... | Use |
| --- | --- |
| Juntar textos | concat |
| Trocar parte de um texto | replace |
| Pegar um pedaço do texto | substring (a primeira posição é 0) |
| Dividir texto em lista | split |
| Juntar lista em texto | join |
| Contar itens ou caracteres | length |
| Somar dias a uma data | addDays |
| Tirar espaços das pontas | trim |

## Como testar com segurança

- Crie um fluxo de teste separado do fluxo de produção.
- Use dados fictícios que representem os casos reais, inclusive o campo vazio.

- Depois de rodar, abra o histórico de execução e veja as Entradas e as Saídas da ação que usa a expressão.
- Teste os casos de borda: campo ausente, vazio, com espaços, com acento e com valor muito longo.

- Só então aplique no fluxo definitivo.

## Erros que todo mundo comete

- Escrever o nome errado de uma ação: body('Obter_item') precisa do nome exato da ação, com sublinhado no lugar dos espaços.
- Assumir que a data está em horário local quando está em UTC.

- Converter texto decimal em inteiro: int('3.14') e também int(float('3.14')) dão erro (testado no Power Automate). Use int(formatNumber(float('3.14'), 'F0')), que arredonda, ou calcule com inteiros desde o início. Outra armadilha: float('1,5') devolve 15 (a vírgula é descartada, sem erro).
- Dividir dois inteiros esperando decimal: div(75, 200) devolve 0.
- Comparar textos sem saber a regra de maiúsculas: equals e contains diferenciam, startsWith, endsWith e indexOf não.
- Copiar uma expressão da internet sem trocar o nome do campo pelo seu.

Para continuar, veja como dividir um valor em parcelas sem perder centavos (https://meajudaflow.com.br/guias/parcelas-power-automate-resto-na-ultima) e como gerar um código sequencial (https://meajudaflow.com.br/guias/sharepoint-codigo-sequencial-pag-00001).

Fontes oficiais:
- Reference guide to functions in expressions (Microsoft Learn): https://learn.microsoft.com/azure/logic-apps/expression-functions-reference
- Expression cookbook for cloud flows (Microsoft Learn): https://learn.microsoft.com/power-automate/expression-cookbook
- Use data operations in Power Automate (Microsoft Learn): https://learn.microsoft.com/power-automate/data-operations

## JSON para iniciantes

URL: https://meajudaflow.com.br/guias/json-para-iniciantes
Atualizado em: 2026-11-02

JSON é a forma mais comum de APIs, conectores e automações trocarem dados. Aprender a ler a estrutura facilita muito a depuração, e é bem mais simples do que parece.

## O que é JSON

JSON (JavaScript Object Notation) é um formato de texto para representar dados estruturados. Apesar do nome, não é exclusivo do JavaScript: praticamente toda linguagem e toda API o entende. É o formato das respostas de APIs, da saída de muitas ações do Power Automate e de arquivos de configuração.

Um JSON é sempre um único valor: um objeto, uma lista, um texto, um número, verdadeiro/falso ou nulo. Na prática, quase sempre é um objeto ou uma lista.

## Objeto: pares nome e valor

Um objeto agrupa propriedades entre chaves. Cada propriedade tem um nome entre aspas duplas, dois pontos e um valor:

```
{"nome":"Ana","idade":31,"ativo":true}
```

## Array: lista ordenada

Um array é uma lista entre colchetes, com itens separados por vírgula:

```
["azul","verde","amarelo"]
```

## Estruturas dentro de estruturas

Objetos e arrays podem conter outros objetos e arrays, em qualquer profundidade. Este é o formato de uma resposta típica de API:

```
{
  "pedido": 1042,
  "cliente": {"nome": "Ana", "cidade": "Recife"},
  "itens": [
    {"sku": "A1", "qtd": 2},
    {"sku": "B2", "qtd": 1}
  ]
}
```

Aqui cliente é um objeto e itens é um array de objetos. Cole o seu JSON no formatador (https://meajudaflow.com.br/tools/json) para ver essa estrutura organizada.

## Os seis tipos de valor

| Tipo | Exemplo | Observação |
| --- | --- | --- |
| Texto (string) | "Recife" | Sempre aspas duplas |
| Número | 31, 10.5, -2 | Sem aspas; ponto como decimal; sem zero à esquerda |
| Booleano | true, false | Minúsculas, sem aspas |
| Nulo | null | Ausência intencional de valor |
| Objeto | {"a":1} | Nomes entre aspas duplas |
| Array | [1,2,3] | Itens separados por vírgula |

## Lendo um JSON no Power Automate

Para acessar um campo, siga o caminho da estrutura. Suponha que a ação Analisar JSON tenha recebido o pedido acima e use o corpo do gatilho:

```
triggerBody()?['cliente']?['nome']
```

Devolve Ana: entra no objeto cliente e pega o nome. Para listas:

```
length(triggerBody()?['itens'])
```

```
first(triggerBody()?['itens'])?['sku']
```

O primeiro devolve a quantidade de itens (2), o segundo o sku do primeiro item (A1). Para percorrer todos os itens, use um Aplicar a cada sobre triggerBody()?['itens'].

Se o JSON chega como texto (por exemplo, a resposta de uma ação HTTP), use Analisar JSON com um esquema gerado a partir de um exemplo real. Assim os campos aparecem no conteúdo dinâmico.

Testado no Power Automate: com o pedido acima, [...]?['cliente']?['nome'] devolveu Ana, length(...['itens']) devolveu 2 e first(...['itens'])?['sku'] devolveu A1. Um caminho que não existe (...?['naoExiste']?['x']) devolve nulo, sem derrubar o fluxo, graças ao ?.

## Os erros de sintaxe mais comuns

- Aspas simples: {'a':1} é inválido. Use aspas duplas.
- Vírgula sobrando depois do último item: [1,2,].

- Nome sem aspas: {a:1} é JavaScript, não JSON.
- Chave ou colchete sem fechar. Quando o JSON é grande, procure a chave que não tem par.

- Comentários: JSON não aceita // nem /* */.
- Esperar um objeto quando a resposta é um array (ou o contrário): confira o primeiro caractere, { ou [.

O formatador (https://meajudaflow.com.br/tools/json) mostra a linha e a coluna de cada erro.

## Um cuidado com números grandes

Alguns sistemas guardam IDs com 16 ou mais dígitos. Ferramentas baseadas em JavaScript convertem esses números em ponto flutuante e podem arredondá-los sem avisar: 9007199254740993 vira 9007199254740992. Se o ID precisa ser exato, trate-o como texto entre aspas ou use um formatador que preserve o número, como o do Me Ajuda Flow.

## Para praticar

- Pegue uma saída real de ação no histórico do Power Automate e cole no formatador.
- Identifique o que é objeto e o que é array.

- Escreva o caminho até um campo dentro de um array de objetos.
- Estrague o JSON de propósito (tire uma aspa) e leia a mensagem de erro.

Fontes oficiais:
- RFC 8259: The JSON Data Interchange Format: https://www.rfc-editor.org/rfc/rfc8259
- Working with JSON (MDN Web Docs): https://developer.mozilla.org/docs/Learn_web_development/Core/Scripting/JSON
- Parse JSON action in Power Automate (Microsoft Learn): https://learn.microsoft.com/power-automate/data-operations

## CSV ou JSON: quando usar cada um?

URL: https://meajudaflow.com.br/guias/csv-para-json
Atualizado em: 2026-11-02

Os dois formatos aparecem o tempo todo em integrações, mas representam dados de formas diferentes. Escolher o formato certo (e saber converter sem perder nada) evita muita dor de cabeça.

## CSV: uma tabela em texto

CSV (comma-separated values) guarda uma tabela como texto: uma linha por registro, campos separados por um caractere. A primeira linha costuma ser o cabeçalho. É o formato de exportação de planilhas, sistemas de gestão e relatórios.

```
nome,cidade
Ana,Recife
Bruno,Curitiba
```

## JSON: dados com estrutura

JSON guarda objetos, listas e estruturas aninhadas, com tipos (texto, número, verdadeiro/falso, nulo). É o formato que APIs e conectores usam. Veja o guia de JSON para iniciantes (https://meajudaflow.com.br/guias/json-para-iniciantes).

```
[{"nome":"Ana","cidade":"Recife"},{"nome":"Bruno","cidade":"Curitiba"}]
```

## Comparação rápida

|  | CSV | JSON |
| --- | --- | --- |
| Estrutura | Só tabela (linhas e colunas) | Hierarquias, listas dentro de objetos |
| Tipos | Tudo é texto | Texto, número, booleano, nulo |
| Tamanho | Menor (nomes das colunas uma vez só) | Maior (nomes repetidos em cada item) |
| Abre no Excel | Direto | Precisa de conversão |
| Ideal para | Planilhas, exportação, cargas em massa | APIs, conectores, dados aninhados |

## Quando usar cada um

- CSV quando os dados são uma tabela simples e vão para (ou vêm de) uma planilha.
- JSON quando existe hierarquia (um pedido com vários itens), quando os tipos importam ou quando o destino é uma API.

## Os problemas clássicos da conversão

- Separador: o Excel em português salva CSV com ponto e vírgula, porque a vírgula é o separador decimal no Brasil. Um conversor que só entende vírgula junta tudo em uma coluna.
- Acentos: arquivos do Excel antigo usam Windows-1252; o padrão atual é UTF-8. Ler com a codificação errada transforma "São" em "São".

- Aspas e quebras de linha: pelo padrão do CSV, um campo com vírgula ou quebra de linha vai entre aspas, e uma aspa dentro do campo é escrita duas vezes ("disse ""oi"""). Conversores simples quebram nesses casos.
- Tipos: o CSV não distingue número de texto. 007 pode virar 7 se o conversor "ajudar". Códigos, CEPs e telefones devem ficar como texto.

- Decimais: 32,90 é texto, não número, para quase todo conversor. Troque a vírgula por ponto se precisar do número. No Power Automate, o perigo é maior: float('32,90') devolve 3290 (a vírgula é descartada, sem erro) e float('1.234,56') dá erro. Veja a limpeza no guia de parcelas (https://meajudaflow.com.br/guias/parcelas-power-automate-resto-na-ultima).
- Cabeçalho repetido ou vazio: colunas duplicadas se sobrescrevem em silêncio em muitos conversores.

O conversor do Me Ajuda Flow (https://meajudaflow.com.br/tools/csv-json) trata esses casos: detecta o separador, lê as duas codificações, renomeia colunas repetidas e avisa o que ajustou.

## E no Power Automate?

O fluxo tem a ação Criar tabela CSV, que transforma uma lista (JSON) em CSV. O caminho inverso, ler CSV e gravar em outro lugar, não tem ação pronta para todos os casos. Uma solução limpa, sem percorrer o arquivo linha por linha, é entregar o texto a um Office Script. Veja o passo a passo em CSV recebido por e-mail para tabela do Excel, sem loop (https://meajudaflow.com.br/guias/csv-do-email-para-tabela-excel-sem-loop).

## Resumo

Use CSV para tabelas e planilhas, JSON para estrutura e APIs. Na conversão, confira separador, codificação, aspas e tipos. Na dúvida, converta uma amostra pequena e compare o resultado com o original antes de processar o arquivo inteiro.

Fontes oficiais:
- RFC 4180: Common Format and MIME Type for CSV Files: https://www.rfc-editor.org/rfc/rfc4180
- RFC 8259: The JSON Data Interchange Format: https://www.rfc-editor.org/rfc/rfc8259
- Run Office Scripts with Power Automate (Microsoft Learn): https://learn.microsoft.com/office/dev/scripts/develop/power-automate-integration

## Erro 429 no Power Automate: causas e como corrigir

URL: https://meajudaflow.com.br/guias/power-automate-erro-429
Atualizado em: 2026-11-02

O erro 429 não significa que o seu fluxo está errado: significa que ele pediu demais, rápido demais. Veja como descobrir qual limite foi atingido e o que mudar, em ordem de eficácia.

## O que o erro 429 significa

429 TooManyRequests é a resposta de um serviço que recusa pedidos porque chegaram mais do que ele aceita em um intervalo de tempo. O pedido em si está correto; ele foi enviado com frequência demais. No Power Automate a mensagem costuma ser parecida com Rate limit is exceeded. Try again in 27 seconds.

A boa notícia: quase sempre dá para resolver sem refazer o fluxo. A má: aumentar o paralelismo "para ir mais rápido" costuma piorar.

## Passo 1: descubra qual limite você atingiu

Há mais de um tipo de limite, e cada um tem uma correção diferente:

| Sintoma | Limite | O que ajuda |
| --- | --- | --- |
| 429 em um conector específico, com "Rate limit is exceeded" | Limite do conector | Espaçar as chamadas, agrupá-las em lote ou reduzir a concorrência |
| Ações atrasadas no fluxo inteiro e muitas ações por dia | Limite diário de ações | Menos requisições, ou mais capacidade de licença (fale com o administrador) |
| Erros ao chamar o Dataverse sob carga | Proteção de serviço do Dataverse | Reduzir a taxa de requisições |

Exemplo de limite de conector: o do SharePoint aceita cerca de 600 operações por minuto por conexão, e a mesma conexão usada em vários fluxos soma no mesmo limite. Isso explica por que um fluxo "inocente" falha quando outro roda ao mesmo tempo.

## Passo 2: reduza a concorrência

Esta é a correção que a própria documentação da Microsoft indica primeiro. O Aplicar a cada (Apply to each) roda um item por vez por padrão; se alguém ativou a concorrência (de 1 a 50), todos esses itens passam a chamar o serviço ao mesmo tempo.

- No Aplicar a cada, clique em ... e em Configurações.
- Em Controle de simultaneidade, reduza o grau de paralelismo (use 1 para processar um item por vez).
- Se o fluxo é iniciado por um gatilho que recebe muitos eventos (por exemplo, arquivos criados em uma pasta), faça o mesmo nas configurações do gatilho.

Lembre-se: um número alto de paralelismo não garante mais velocidade, porque a espera do serviço chamado e o enfileiramento também custam tempo. Teste valores baixos primeiro.

## Passo 3: faça menos requisições

Toda ação conta como requisição, inclusive as internas, como inicializar variável ou compor. Retentativas e paginação também contam. Reduções que costumam funcionar:

- Condições de gatilho: o fluxo só roda quando o item realmente interessa. Um fluxo que dispara para todo e-mail e só depois verifica o remetente gasta requisições em todos.
- Filtrar na origem: use a consulta de filtro (OData) no conector em vez de trazer tudo e testar item por item dentro de um loop.
- Selecionar e Filtrar matriz no lugar de loops quando você só está transformando dados, não agindo em cada item.
- Retire retentativas que não ajudam: cada uma conta como ação.

Conta de padaria: uma loja de material de construção atualiza 3.000 itens de estoque em uma lista do SharePoint, um item por ação. Com o limite de 600 operações por minuto, o mínimo teórico é 3.000 ÷ 600 = 5 minutos. Se o fluxo tentar fazer tudo em 1 minuto com paralelismo 50, a chance de tomar 429 é alta. O caminho certo é aceitar os 5 minutos (ou mais) e desenhar o fluxo para isso.

## Passo 4: espace as chamadas e repita com critério

Dentro de um loop sequencial, uma ação Atraso (Delay) entre as chamadas deixa o fluxo abaixo do limite do conector.

Para falhas passageiras, configure a política de repetição na ação (... > Configurações > Política de repetição):

- A Microsoft recomenda a política exponencial: o intervalo cresce a cada tentativa, o que dá tempo ao serviço para se recuperar.
- Você define a quantidade de repetições e o intervalo em formato ISO 8601, por exemplo PT30S para 30 segundos. Na documentação da plataforma, a quantidade vai de 1 a 90.
- Na política padrão da maioria das operações, são até 4 repetições com intervalos crescentes entre 5 e 45 segundos.

O SharePoint Online devolve junto do 429 o cabeçalho Retry-After, com quantos segundos esperar. A Microsoft avisa que ignorar essa espera pode aumentar o tempo de bloqueio, e quem insiste em exceder os limites pode ser bloqueado de vez.

## Passo 5: use operações em lote quando existirem

Para criar ou atualizar milhares de registros, a documentação desaconselha um loop item a item. Conectores e APIs que aceitam lote permitem agrupar várias operações em uma única requisição (por exemplo, o lote da API REST do SharePoint chamado por uma ação HTTP). No Dataverse existem as operações em massa (bulk), que contam como uma operação só.

## O que não fazer

- Não aumentar a concorrência para "acelerar" um fluxo que já toma 429.
- Não configurar repetições sem espaçamento: elas contam como ações e pioram o problema.
- Não dividir o mesmo volume em vários fluxos que usam a mesma conexão: o limite do conector é por conexão.

## Checklist rápido

- Li a mensagem completa do erro e identifiquei o conector.
- Reduzi o paralelismo do loop e do gatilho.
- Adicionei condição de gatilho e filtro na origem.
- Troquei loops por Selecionar/Filtrar matriz onde era só transformação.
- Configurei política de repetição exponencial e, se preciso, um Atraso.
- Calculei o tempo mínimo (itens ÷ limite por minuto) e aceitei esse prazo.

Fontes oficiais:
- Too many requests error in Power Automate (Microsoft Learn): https://learn.microsoft.com/troubleshoot/power-platform/ai-builder/power-automate/too-many-requests-error-in-power-automate
- Understand platform limits and avoid throttling (Microsoft Learn): https://learn.microsoft.com/power-automate/guidance/coding-guidelines/understand-limits
- Optimize flows with parallel execution and concurrency (Microsoft Learn): https://learn.microsoft.com/power-automate/guidance/coding-guidelines/implement-parallel-execution
- Employ robust error handling: retry policy (Microsoft Learn): https://learn.microsoft.com/power-automate/guidance/coding-guidelines/error-handling
- Retry policies (Azure Logic Apps, base do Power Automate): https://learn.microsoft.com/azure/logic-apps/error-exception-handling#retry-policies
- Avoid getting throttled or blocked in SharePoint Online: https://learn.microsoft.com/sharepoint/dev/general-development/how-to-avoid-getting-throttled-or-blocked-in-sharepoint-online

## CSV recebido por e-mail para tabela do Excel, sem loop

URL: https://meajudaflow.com.br/guias/csv-do-email-para-tabela-excel-sem-loop
Atualizado em: 2026-11-02

Em vez de percorrer o arquivo linha por linha, o fluxo entrega o texto inteiro do CSV a um Office Script, que grava tudo na tabela de uma vez. Menos ações, menos risco de 429 e muito mais rápido.

## O problema

Toda manhã chega um e-mail com um CSV (vendas do dia, estoque, extrato) e alguém copia as linhas para uma planilha. A solução ingênua automatiza isso com um Aplicar a cada: para cada linha do CSV, uma ação Adicionar linha a uma tabela. Funciona com 20 linhas e vira um pesadelo com 5.000: cada linha é uma ação, o fluxo demora, consome o limite de ações e, no pior caso, atinge o erro 429 (https://meajudaflow.com.br/guias/power-automate-erro-429).

A alternativa é entregar o CSV inteiro a um Office Script, um pequeno código que roda dentro do Excel na web e grava todas as linhas em lote. Para o fluxo, é uma única ação.

## O que você precisa

- Uma licença Microsoft 365 empresarial com Office Scripts habilitado. Segundo a Microsoft, para usar Office Scripts no Power Automate é preciso uma licença empresarial do Microsoft 365.
- Uma pasta de trabalho do Excel salva no OneDrive for Business ou no SharePoint (não vale arquivo só no seu computador).
- Nessa pasta de trabalho, uma tabela (Inserir > Tabela) chamada TabelaDados, com os cabeçalhos na mesma ordem das colunas do CSV.

## Passo 1: crie o script

No Excel na web, abra Automatizar > Novo script > Criar no editor de código, apague o conteúdo e cole o código abaixo. Salve com o nome Gravar CSV na tabela.

```
function main(
  workbook: ExcelScript.Workbook,
  csv: string,
  tableName: string = "TabelaDados"
): string {
  const table = workbook.getTable(tableName);
  if (!table) {
    throw new Error("Tabela não encontrada: " + tableName);
  }
  const rows = parseCsv(csv);
  if (rows.length  normalize(r, columns));
  // Grava em blocos de 500 linhas para ficar longe dos limites de tamanho
  for (let i = 0; i  best) {
      best = counts[d];
      delimiter = d;
    }
  }

  const rows: string[][] = [];
  let row: string[] = [];
  let value = "";
  let quoted = false;
  let fieldStart = true;
  for (let i = 0; i  r.some((cell) => cell !== ""));
}
```

Testado: a parte de leitura do CSV (parseCsv e normalize) é executada por testes automatizados do Me Ajuda Flow com vírgula, ponto e vírgula, Tab, aspas, aspas escapadas, quebra de linha dentro de aspas, BOM, linhas em branco e linhas mais curtas ou mais longas que a tabela. A gravação no Excel (main) segue a documentação oficial e deve ser testada no seu ambiente.

O que o script faz: lê o CSV (detecta sozinho se o separador é vírgula, ponto e vírgula ou Tab), ajusta cada linha ao número de colunas da tabela (completa com vazio ou descarta o excesso) e grava em blocos de 500 linhas.

## Passo 2: monte o fluxo

- Gatilho: Office 365 Outlook, Quando um novo e-mail chegar (V3). Em Opções avançadas, deixe Somente com anexo = Sim e Incluir anexos = Sim. Filtre por remetente ou assunto, para o fluxo não disparar com qualquer e-mail.
- Filtrar matriz (para ignorar imagens de assinatura e outros anexos): em De, use triggerOutputs()?['body/attachments'] e, na condição avançada, endsWith(item()?['name'], '.csv'). Renomeie a ação para Filtrar_anexos.

- Executar script (Excel Online (Business)): escolha o arquivo pelo seletor, o script Gravar CSV na tabela e preencha os parâmetros. Em csv, use a expressão: ``` base64ToString(first(body('Filtrar_anexos'))?['contentBytes']) ``` Em tableName, escreva TabelaDados.
- Opcional: um e-mail ou uma mensagem no Teams confirmando, com o texto que o script devolve (quantas linhas foram adicionadas).

Acentos trocados? A conversão do anexo parte do princípio de que o arquivo está em UTF-8. Se aparecerem símbolos no lugar de acentos, o CSV de origem provavelmente foi salvo em Windows-1252 (testado: um anexo em Windows-1252 com a palavra "Olá" chega ao fluxo como "Ol�"). Salve (ou exporte) como "CSV UTF-8" na origem. Você pode conferir no conversor CSV para JSON (https://meajudaflow.com.br/tools/csv-json), que reconhece as duas codificações.

Executado no Power Automate: as duas expressões de anexo foram executadas em 02/11/2026, em um fluxo de teste, com uma lista de dois anexos (assinatura.png e Vendas.CSV). O Filtrar matriz devolveu só o Vendas.CSV (o endsWith não diferencia .CSV de .csv), e base64ToString(first(body('Filtrar_anexos'))?['contentBytes']) devolveu o texto nome;valor e Ana;1,5, com a quebra de linha. A gravação no Excel pelo script não foi executada nesse teste.

## Limites que você precisa conhecer

| Limite | Valor |
| --- | --- |
| Tamanho de requisição e resposta do Excel | 5 MB |
| Tamanho máximo dos parâmetros da ação Executar script | 30.000.000 bytes |
| Tempo máximo de uma operação síncrona do Power Automate | 120 segundos |
| Chamadas da ação Executar script por usuário | 1.600 por dia (zera às 00:00 UTC) |
| Chamadas externas (fetch) dentro do script | Não funcionam no Power Automate |

Para CSV muito grande, divida o arquivo ou chame o script mais de uma vez com partes menores. O script já grava em blocos para não estourar o limite de tamanho em uma única gravação.

## Armadilhas

- Excel interpretando valores: textos que parecem número ou data (como 007 ou 01/02) podem ser convertidos ao serem gravados. Se precisar preservar zeros à esquerda, formate a coluna como Texto antes.
- Tabela não encontrada: o nome do segundo parâmetro precisa ser exatamente o da tabela (Design da tabela > Nome da tabela).

- Parâmetros novos não aparecem na ação: se você mudou o script depois de adicionar a ação, o Power Automate guarda a assinatura antiga. Remova a ação e adicione de novo.
- Vários CSV no mesmo e-mail: este fluxo pega o primeiro. Para vários, será preciso repetir a ação para cada anexo.

- Dados duplicados: se o mesmo e-mail disparar o fluxo duas vezes, as linhas entram duas vezes. Se isso for um risco, grave uma coluna com o identificador do arquivo e confira antes.

## Como testar antes de confiar

- Envie para você mesmo um CSV pequeno (3 linhas), com acentos e uma célula com vírgula entre aspas.
- Abra a execução no histórico e confira a saída da ação Executar script: deve dizer "3 linhas adicionadas".
- Abra a tabela no Excel e confira acentos, colunas e valores.
- Só então teste com um arquivo real, e depois com um grande.

Fontes oficiais:
- Run Office Scripts with Power Automate (Microsoft Learn): https://learn.microsoft.com/office/dev/scripts/develop/power-automate-integration
- Platform limits and requirements with Office Scripts (Microsoft Learn): https://learn.microsoft.com/office/dev/scripts/testing/platform-limits
- Sample: Convert CSV files to Excel workbooks (Microsoft Learn): https://learn.microsoft.com/office/dev/scripts/resources/samples/convert-csv
- Sample: Write a large dataset (Microsoft Learn): https://learn.microsoft.com/office/dev/scripts/resources/samples/write-large-dataset
- Troubleshoot Office Scripts running in Power Automate (Microsoft Learn): https://learn.microsoft.com/office/dev/scripts/testing/power-automate-troubleshooting

## Mudei a pergunta no Forms e o fluxo quebrou

URL: https://meajudaflow.com.br/guias/forms-mudei-a-pergunta-e-o-fluxo-quebrou
Atualizado em: 2026-11-02

Você ajustou um formulário, o Power Automate continuou sem dar erro, mas campos chegam vazios ou as condições deixam de funcionar. Aqui está o método para achar o que mudou e corrigir.

Sobre este guia: a Microsoft documenta como ligar o Forms ao Power Automate, mas não descreve o que acontece com os campos quando uma pergunta é editada. O comportamento descrito abaixo vem de uso prático e pode variar. Por isso o guia ensina a verificar no seu formulário, em vez de afirmar regras.

## Como o fluxo lê o formulário

O conector do Forms tem um gatilho, Quando uma nova resposta for enviada, e uma ação, Obter detalhes da resposta. É essa ação que traz as respostas como conteúdo dinâmico para o resto do fluxo. Cada resposta é associada internamente a um identificador da pergunta; é por ele que o campo aparece na saída da ação.

O ponto frágil: se a pergunta é alterada de um jeito que o Forms trata como outra pergunta (trocar o tipo, ou excluir e recriar), o fluxo pode continuar apontando para o campo antigo. Como o Power Automate trata um campo inexistente como "vazio", o fluxo não falha: ele segue com valores em branco, e o erro só aparece depois (e-mail sem dados, linha vazia na planilha, condição que nunca é verdadeira).

## Diagnóstico em 5 passos

- Envie uma resposta de teste nova no formulário já editado. Não reexecute uma execução antiga: ela reaproveita os dados da resposta antiga.
- No Power Automate, abra a execução em Histórico de execuções de 28 dias.

- Expanda Obter detalhes da resposta e leia as Saídas. Cada pergunta aparece com um identificador interno (costuma começar com r) seguido do valor. Confirme que a pergunta editada aparece e com a resposta que você enviou.
- Abra as ações seguintes e veja, nas Entradas, quais campos chegaram em branco.

- Compare: o campo em branco aponta para um identificador que não existe mais na saída do passo 3? Achou o problema.

## Como corrigir

- Abra o fluxo no editor e clique em Obter detalhes da resposta. Confirme que o ID do formulário está selecionado.
- Nas ações que usam o campo, apague o conteúdo dinâmico antigo e selecione de novo o campo da pergunta, na lista que aparece.

- Salve, envie outra resposta de teste e repita o diagnóstico.

## O formato da resposta depende do tipo da pergunta

Quando você troca o tipo de pergunta, o formato da resposta muda, e as expressões que liam o formato antigo deixam de servir:

- Escolha única: chega como texto simples. Uma condição com equals funciona.
- Múltipla escolha (várias opções): a resposta traz mais de um valor. Dependendo de como chega, pode ser uma lista ou um texto com formato de lista. Para saber qual é o seu caso, adicione uma ação Compor com o campo e olhe a saída no histórico. Se a lista já vier como matriz, join junta os itens em um texto. Se vier como texto, converta antes com json: ``` join(json(outputs('Resposta_multipla')), ', ') ``` Para testar se uma opção específica foi marcada, use contains, que funciona com várias opções, em vez de equals, que só compara com um valor exato: ``` contains(outputs('Resposta_multipla'), 'Cimento') ```

- Upload de arquivo: a Microsoft documenta que a saída é um texto em JSON, e é preciso uma ação Analisar JSON (Parse JSON) para extrair o arquivo. Gere o esquema colando uma saída real; o formatador JSON (https://meajudaflow.com.br/tools/json) ajuda a ler essa saída.

Testado no Power Automate (02/11/2026), com uma resposta com as opções Cimento e Areia:
- Resposta como texto no formato de lista: join(json(...), ', ') devolve Cimento, Areia; contains(texto, 'Cimento') devolve true, contains(texto, 'Cim') também devolve true (procura um trecho do texto) e equals(texto, 'Cimento') devolve false.
- Resposta como lista de verdade: join(lista, ', ') devolve Cimento, Areia; contains(lista, 'Cimento') devolve true e contains(lista, 'Cim') devolve false (só aceita o item inteiro).
- contains diferencia maiúsculas de minúsculas.

Ou seja: com a resposta em texto, contains pode dar falso positivo (uma opção "Cimento Branco" também contém "Cimento"). Confira o formato no histórico antes de escolher a condição.

Dica: se uma condição "parou de funcionar" depois de mudar uma pergunta de múltipla para única (ou o contrário), o suspeito número um é um equals onde antes havia contains, ou o inverso. Confira a saída no histórico antes de reescrever a condição.

## Como evitar o problema

- Congele o formulário depois de ligar o fluxo. Mudanças estruturais (tipo, exclusão, recriação) devem ser exceção, não rotina.
- Teste mudanças em uma cópia do formulário e do fluxo. Só repita no original depois de validar.

- Use uma ação Compor por resposta importante, com nome claro (Resposta_valor, Resposta_projeto). O resto do fluxo lê do Compor, e uma mudança no formulário obriga a corrigir só em um lugar.
- Valide campos obrigatórios: adicione logo após a ação Obter detalhes uma condição que verifica se os campos críticos não estão vazios (empty(...)) e avisa você quando estiverem.

- Anote mudanças no comentário da ação ou em um registro simples (data, o que mudou, quem mudou).

Fontes oficiais:
- Overview of flows with Microsoft Forms (Microsoft Learn): https://learn.microsoft.com/power-automate/forms/overview
- Common ways to use a form in a flow (Microsoft Learn): https://learn.microsoft.com/power-automate/forms/popular-scenarios
- Expression cookbook for cloud flows (Microsoft Learn): https://learn.microsoft.com/power-automate/expression-cookbook

## Parcelas no Power Automate sem perder centavos

URL: https://meajudaflow.com.br/guias/parcelas-power-automate-resto-na-ultima
Atualizado em: 2026-11-02

R$ 100,00 em 3 vezes não é 33,33 + 33,33 + 33,33: falta 1 centavo. Veja como dividir em centavos, jogar o resto na última parcela e gerar os vencimentos, sem depender de uma função de arredondar que o Power Automate não tem.

## O problema

Dividir 100,00 por 3 dá 33,333... Se você arredondar cada parcela para 33,33, a soma das três é 99,99: sumiu 1 centavo. Em financeiro, isso vira divergência de conciliação. A regra prática é: todas as parcelas recebem o valor-base, e a última recebe o valor-base mais o resto, de modo que a soma bata exatamente com o total.

Há um obstáculo no Power Automate: a lista de funções matemáticas (add, div, max, min, mod, mul, rand, range, sub) não tem função de arredondamento (e a pow, que aparece em algumas referências, também não existe: o fluxo responde "The template function 'pow' is not defined"). A saída é trabalhar com números inteiros em centavos, onde a divisão e o resto são exatos.

## Por que trabalhar em centavos

- Com dois números inteiros, div devolve a parte inteira da divisão e mod devolve o resto. É exatamente o que precisamos.
- Decimais em ponto flutuante trazem resíduos. Testado no Power Automate: mul(19.99, 100) devolve 1998.9999999999998 (e não 1999) e add(0.1, 0.2) devolve 0.30000000000000004. Por isso o valor é convertido por texto, e não por multiplicação.

- A documentação alerta que a divisão de inteiros trunca: div(75, 200) retorna 0. Aqui isso é uma vantagem, desde que seja intencional.

## Passo a passo

Suponha que o fluxo receba valor (por exemplo, 1000.00), parcelas (por exemplo, 3) e a data da primeira cobrança.

- Variável inteira parcelas, com o valor: ``` int(triggerBody()?['parcelas']) ```
- Variável inteira totalCentavos. Formatamos o valor com duas casas e ponto decimal, tiramos o ponto e convertemos em inteiro: ``` int(replace(formatNumber(float(triggerBody()?['valor']), '0.00', 'en-US'), '.', '')) ``` Para 1000.00, o texto formatado é 1000.00, que vira 100000. A cultura en-US garante o ponto como separador, independentemente da configuração regional do fluxo. Se o valor vier com mais de duas casas, o formatNumber arredonda para duas, mas o arredondamento de metades não é uniforme (testado: formatNumber(0.125, '0.00') devolve 0.13 e formatNumber(2.675, 'F2') devolve 2.67). Limite as casas decimais na origem.

- Variável base (valor de cada parcela, em centavos): ``` div(variables('totalCentavos'), variables('parcelas')) ```
- Variável resto: ``` mod(variables('totalCentavos'), variables('parcelas')) ```

- Aplicar a cada sobre a sequência de 1 até o número de parcelas: ``` range(1, variables('parcelas')) ``` O range(1, 3) devolve [1, 2, 3] (a partir do 1, na quantidade informada).
- Dentro do loop, uma ação Compor chamada Valor_parcela_centavos, com o valor desta parcela: a última recebe a base mais o resto. ``` if(equals(items('Aplicar_a_cada'), variables('parcelas')), add(variables('base'), variables('resto')), variables('base')) ```

- Outra ação Compor, Valor_parcela_texto, para mostrar em reais no formato brasileiro: ``` formatNumber(div(float(outputs('Valor_parcela_centavos')), 100), 'N2', 'pt-BR') ``` Para 33333 centavos, o resultado é 333,33.
- E o vencimento. Para parcelas a cada 30 dias, a primeira em 30 dias: ``` addDays(utcNow(), mul(items('Aplicar_a_cada'), 30), 'yyyy-MM-dd') ``` Para vencimento no mesmo dia de cada mês, prefira addToTime(data, número, 'Month'), que respeita o calendário.

Executado no Power Automate: o fluxo deste guia (variáveis, range, Aplicar a cada, if, addDays) foi montado e executado em 02/11/2026, em um fluxo de teste sem conectores. Para R$ 1.000,00 em 3 vezes, a primeira parcela em 30 dias a partir de 02/11/2026, o resultado foi: 333,33 em 2026-12-02, 333,33 em 2027-01-01 e 333,34 em 2027-01-31. A calculadora de parcelas (https://meajudaflow.com.br/tools/parcelas) do Me Ajuda Flow produz exatamente os mesmos valores.

## Conferindo as contas (R$ 1.000,00 em 3 vezes)

| Item | Resultado |
| --- | --- |
| totalCentavos | 100000 |
| base = div(100000, 3) | 33333 |
| resto = mod(100000, 3) | 1 |
| Parcela 1 | R$ 333,33 |
| Parcela 2 | R$ 333,33 |
| Parcela 3 (base + resto = 33334) | R$ 333,34 |
| Soma | R$ 1.000,00 |

Outro exemplo, R$ 100,00 em 3 vezes: 10000 ÷ 3 = 3333 com resto 1, então as parcelas são 33,33, 33,33 e 33,34.

Cuidados:
- O nome Aplicar_a_cada nas expressões deve ser igual ao nome da ação no seu fluxo (espaços viram sublinhado). Se renomear, ajuste.
- Se o valor vier de texto digitado por pessoas no padrão brasileiro, limpe antes de converter. Testado: float('1,5') devolve 15 (a vírgula é descartada, sem erro!) e float('1.234,56') dá erro. A limpeza abaixo resolve 1.234,56 e 1000,50, mas só serve para texto com vírgula decimal: aplicada a 1000.50, devolve 100050. ``` float(replace(replace(triggerBody()?['valor'], '.', ''), ',', '.')) ``` Se houver "R$", retire-o antes com outro replace. Testado com R$ 1.234,56 (devolve 1234.56) e com -1.234,56 (devolve -1234.56).
- Valide parcelas maior que zero antes de dividir: div e mod por zero dão erro.
- Teste com valores extremos: 0,01 em 3 parcelas (parcelas 0, 0 e 1 centavo) e um total que divide exatamente.

Antes de colar qualquer uma dessas expressões no fluxo, passe por ela no verificador de expressões (https://meajudaflow.com.br/tools/power-automate): ele confere aspas, parênteses e nomes de funções em segundos.

Fontes oficiais:
- Expression cookbook for cloud flows (Microsoft Learn): https://learn.microsoft.com/power-automate/expression-cookbook
- Reference guide to functions in expressions (Microsoft Learn): https://learn.microsoft.com/azure/logic-apps/expression-functions-reference

## Chaves de API seguras no Power Automate

URL: https://meajudaflow.com.br/guias/chaves-de-api-seguras-power-automate
Atualizado em: 2026-11-02

Uma chave de API colada direto em uma ação HTTP fica visível para qualquer pessoa que possa abrir o fluxo ou o histórico de execuções. Veja o que não fazer, o mínimo que sempre deve ser feito e a forma recomendada de guardar segredos.

## O risco, em uma frase

O Power Automate permite abrir o histórico de execuções e ver as entradas e saídas de cada ação. A própria Microsoft alerta que deixar senhas ou chaves de API escritas dentro do fluxo as expõe para qualquer pessoa com acesso ao fluxo. Um token no cabeçalho de uma ação HTTP aparece em texto puro nesse histórico.

## O que nunca fazer

- Colar a chave direto no campo de uma ação (cabeçalho Authorization, URL com ?key=, corpo da requisição).
- Guardar a chave em uma variável ou em uma ação Compor: o valor aparece no histórico.

- Enviar a chave por e-mail ou chat para "quem for configurar o fluxo", ou colar em ferramentas públicas (inclusive de Base64 ou JWT).
- Reaproveitar a mesma chave em vários fluxos, ambientes e pessoas.

## Nível 1: entradas e saídas seguras (o mínimo)

Em qualquer ação que lide com um segredo, ative as duas opções:

- Clique em ... na ação e em Configurações.
- Ative Entradas seguras e Saídas seguras e confirme.

Com isso, o histórico passa a mostrar "Conteúdo não exibido devido à configuração de segurança" nessa ação. A documentação da Microsoft aplica as duas opções, por exemplo, na ação HTTP que usa a chave e na ação que busca o segredo.

Atenção: isso esconde o valor do histórico, mas não protege a chave em si: quem edita o fluxo ainda pode ver o que está escrito nele. Por isso o nível 1 só é suficiente se a chave não estiver escrita no fluxo (ver níveis 2 e 3).

## Nível 2: variáveis de ambiente

A Microsoft recomenda usar variáveis de ambiente em vez de valores fixos dentro do fluxo. Você atualiza o valor em um lugar, sem editar o fluxo, e o fluxo deixa de carregar o segredo no próprio desenho. Variáveis de ambiente fazem parte das soluções do Power Platform.

## Nível 3: Azure Key Vault (o recomendado para produção)

O Azure Key Vault é um serviço próprio para guardar segredos, chaves e certificados, com criptografia e controle de acesso por papéis. O Power Automate o usa de duas formas:

- Variável de ambiente do tipo segredo: a variável aponta para o segredo no Key Vault. O fluxo lê o valor na hora de executar, com a ação Executar uma ação não associada do Dataverse, escolhendo RetrieveEnvironmentVariableSecretValue. Segundo a documentação, esses segredos não aparecem no seletor de conteúdo dinâmico, e só ficam disponíveis para fluxos e conectores personalizados.
- Conector do Azure Key Vault: a ação Obter segredo busca o valor direto. A Microsoft recomenda, para produção, conectar com uma entidade de serviço (service principal) em vez de uma conta de usuário.

Nos dois casos, ative Saídas seguras na ação que lê o segredo e Entradas e saídas seguras na ação que o usa (por exemplo, o HTTP). Dependendo do ambiente, será preciso a ajuda do administrador do Azure para dar ao Power Platform permissão de leitura do segredo.

## Se a chave vazou

- Revogue ou gire a chave agora, no serviço que a emitiu. Trocar a chave é mais importante do que descobrir quem viu.
- Atualize o valor no Key Vault (ou na variável de ambiente). Se o fluxo lê de lá, nada precisa ser editado.

- Veja o histórico de uso da chave no serviço de origem, atrás de chamadas que você não reconhece.
- Procure onde mais ela pode estar: outros fluxos, mensagens, planilhas, capturas de tela.

## Boas práticas de rotina

- Uma chave por finalidade: se uma vaza, só uma integração é afetada.
- Menor permissão possível: chaves que só leem não devem escrever.

- Quem pode ver o fluxo também vê o histórico. Compartilhe com o mínimo de pessoas e revise co-proprietários periodicamente.
- Troque a chave quando alguém que tinha acesso sair da equipe.

- Nunca publique capturas de tela de fluxos sem conferir se há segredos visíveis.

Um lembrete sobre Base64: ele não protege nada. Um cabeçalho Authorization: Basic ... leva usuário e senha em Base64 só para caber no cabeçalho, e qualquer pessoa que o veja decodifica em um segundo. Use o decodificador (https://meajudaflow.com.br/tools/base64) com dados fictícios para ver isso com os próprios olhos.

Fontes oficiais:
- Secure data used in cloud flows (Microsoft Learn): https://learn.microsoft.com/power-automate/guidance/coding-guidelines/use-secure-inputs-outputs-triggers
- Use environment variables for Azure Key Vault secrets (Microsoft Learn): https://learn.microsoft.com/power-apps/maker/data-platform/environmentvariables-azure-key-vault-secrets
- Recommendations for protecting application secrets (Microsoft Learn): https://learn.microsoft.com/power-platform/well-architected/security/application-secrets
- Azure Key Vault connector (Microsoft Learn): https://learn.microsoft.com/connectors/keyvault/

## Código sequencial no SharePoint: PAG-00001

URL: https://meajudaflow.com.br/guias/sharepoint-codigo-sequencial-pag-00001
Atualizado em: 2026-11-02

Todo mundo quer um número de solicitação bonito, como PAG-00001. O problema é que o ID do item só existe depois que ele é criado. Veja por que a coluna calculada falha e como resolver com um fluxo curto.

## O que queremos

Uma lista de solicitações em que cada item tem um código legível e único: PAG-00001, PAG-00002, e assim por diante. É o que as pessoas citam em e-mails ("pode olhar o PAG-00042?") e o que facilita a busca.

O SharePoint já tem uma coluna ID, que é um número sequencial único gerado pela própria lista. O código é o ID com um prefixo e zeros à esquerda. O desafio: o ID só passa a existir depois que o item é salvo.

## Por que a coluna calculada não funciona

A ideia óbvia é criar uma coluna calculada com a fórmula ="PAG-"&[ID]. Relatos de usuários e respostas de moderadores da Microsoft mostram que isso não é confiável: ao criar o item, a parte do ID vem vazia ou zero, porque o ID ainda não existe na hora em que a fórmula é calculada; e, em alguns casos, a fórmula perde os colchetes e passa a tratar ID como texto. A recomendação nessas respostas é uma das duas alternativas abaixo.

| Alternativa | Guarda o valor? | Quando usar |
| --- | --- | --- |
| Formatação de coluna (JSON) | Não. Só muda como o item é exibido na lista | Quando o código é apenas visual. O valor fica vazio para filtros, buscas e fluxos |
| Fluxo do Power Automate | Sim. Grava o código de verdade em uma coluna de texto | Quando o código precisa ser usado em buscas, relatórios, e-mails e outros fluxos |

O guia segue com o fluxo, que é o caminho que serve em todos os casos.

## Passo a passo

- Crie a coluna de texto na lista: tipo Uma linha de texto, nome Codigo (sem acento e sem espaço no nome interno, o que evita dor de cabeça nas expressões). Se quiser garantir que não haja códigos repetidos, ative Impor valores exclusivos (a coluna será indexada).
- Crie o fluxo automatizado com o gatilho Quando um item é criado (SharePoint), escolhendo o site e a lista. Escolha o gatilho certo: use "Quando um item é criado", e não "criado ou modificado". O fluxo vai alterar o item para gravar o código, e com o gatilho "ou modificado" essa alteração dispararia o próprio fluxo de novo, em um loop sem fim.

- Adicione a ação Atualizar item (SharePoint): mesmo site e lista, Id com o conteúdo dinâmico ID do gatilho e, no campo Codigo, a expressão: ``` concat('PAG-', formatNumber(triggerOutputs()?['body/ID'], '00000')) ``` A função formatNumber com o formato 00000 completa com zeros à esquerda até cinco dígitos: o ID 1 vira 00001, o 42 vira 00042, e o 123456 continua 123456, sem cortar nada. Conferido executando a expressão no Power Automate: o ID 42 gera PAG-00042 e o ID 123456 gera PAG-123456.
- Se a lista tiver colunas obrigatórias, a ação Atualizar item pode pedir esses campos. Preencha com os próprios valores do gatilho.

- Salve e teste: crie 3 itens e confira o código de cada um.

## O que esperar

- Atraso de alguns segundos: o item aparece sem código por instantes, até o fluxo rodar. Se isso incomoda, oculte a coluna na tela de criação e mostre o código só nas visões.
- Buracos na numeração: o ID é gerado pela lista e itens excluídos deixam lacunas (por exemplo, 1, 2, 4). O código acompanha. Se a sua regra exige numeração sem buracos, o ID da lista não é o caminho certo.

- Sem código repetido: como o ID vem da lista, dois itens criados ao mesmo tempo recebem IDs diferentes, e portanto códigos diferentes.
- Itens que já existem: o fluxo só atua em itens novos. Para preencher os antigos, rode um fluxo manual uma vez, com Obter itens e Atualizar item para cada um, respeitando o limite de requisições (https://meajudaflow.com.br/guias/power-automate-erro-429).

- Quem edita o fluxo: o fluxo usa a conexão de quem o criou. Se essa pessoa sair da empresa, a conexão deixa de funcionar. Use uma conta de serviço em produção.

## Variações úteis

- Prefixo com ano: gera algo como PAG-2026-00042. O número continua contínuo, ele não reinicia a cada ano. ``` concat('PAG-', formatDateTime(utcNow(), 'yyyy'), '-', formatNumber(triggerOutputs()?['body/ID'], '00000')) ```
- Mais de um tipo de solicitação: use o mesmo fluxo e escolha o prefixo pelo tipo (aqui, uma coluna de escolha chamada Tipo). ``` concat(if(equals(triggerOutputs()?['body/Tipo/Value'], 'Reembolso'), 'REE-', 'PAG-'), formatNumber(triggerOutputs()?['body/ID'], '00000')) ```

Valide as expressões no verificador (https://meajudaflow.com.br/tools/power-automate) antes de colar no fluxo.

Fontes oficiais:
- Use column formatting to customize SharePoint (Microsoft Learn): https://learn.microsoft.com/sharepoint/dev/declarative-customization/column-formatting
- Expression cookbook for cloud flows (Microsoft Learn): https://learn.microsoft.com/power-automate/expression-cookbook
- Reference guide to functions in expressions (Microsoft Learn): https://learn.microsoft.com/azure/logic-apps/expression-functions-reference

## Por que o PIX copia e cola foi recusado

URL: https://meajudaflow.com.br/guias/por-que-pix-copia-e-cola-foi-recusado
Atualizado em: 2026-11-02

Quando o aplicativo diz que o código é inválido, o problema quase sempre está em um campo específico do BR Code. Veja as causas mais comuns, como cada uma aparece no código e como achar a sua em poucos minutos.

## Como o código é montado


O PIX copia e cola é um texto no padrão BR Code, definido pelo Banco Central a partir do padrão EMV de QR Codes. Ele é uma sequência de campos no formato ID (2 dígitos), tamanho (2 dígitos), valor. Por exemplo, 5802BR é o campo 58 (país), com 2 caracteres, valor BR. O último campo é sempre o 63, o CRC16, que é uma assinatura de todo o texto anterior. Se qualquer caractere mudar, a assinatura deixa de bater e o aplicativo do pagador recusa o código.


Este é um código estático de teste, com dados fictícios, que o decodificador do Me Ajuda Flow lê sem nenhum aviso:



```
00020126470014br.gov.bcb.pix0125financeiro@exemplo.com.br5204000053039865406123.455802BR5918EMPRESA TESTE LTDA6009SAO PAULO62070503***63042103
```


Ele traz a chave financeiro@exemplo.com.br, valor 123.45, nome EMPRESA TESTE LTDA, cidade SAO PAULO e CRC 2103. Abaixo, cada falha é provocada nesse mesmo código, para você ver o que o decodificador mostra.




## 1. O CRC16 não confere


É o erro mais frequente e o que mais engana, porque o texto parece normal. O CRC é calculado sobre todo o texto, incluindo o 6304 que antecede o próprio CRC, com polinômio 1021 (hexadecimal) e valor inicial FFFF, segundo o Manual do BR Code. O resultado são 4 caracteres hexadecimais em maiúsculas. O Manual de Padrões para Iniciação do Pix lembra ainda que a ordem dos campos altera o CRC.


Teste real: no código acima, troquei o valor 123.45 por 923.45 sem recalcular o CRC. O decodificador respondeu: informado 2103, calculado CF80. Ou seja, o código foi alterado depois de gerado.




- Causa típica: alguém editou o valor, o nome ou a chave à mão, ou um sistema trocou um caractere (aspas "inteligentes", espaço no meio, quebra de linha).
- Como resolver: peça um código novo a quem recebe, ou gere de novo no sistema de origem. Não adianta corrigir só o CRC se o conteúdo foi adulterado: o código deve vir de quem recebe.




## 2. Código copiado pela metade


Mensagens de WhatsApp, e-mails e PDFs costumam quebrar o texto. Quando o final se perde, falta o CRC e, muitas vezes, o último campo fica incompleto.


Teste real: cortei os últimos 12 caracteres do código. O decodificador avisou que o campo 62 declara 7 caracteres, mas só restam 3, e que falta o campo 63 com 4 caracteres. O sinal clássico é esse: um campo que promete mais dados do que existem. Se o código termina em 6304 sem os 4 caracteres seguintes, o CRC foi cortado.




- Copie de novo, do início (000201) ao fim, sem apertar Enter no meio.
- Quebras de linha e espaços nas pontas são removidos pelo decodificador, mas alguns aplicativos de banco não os aceitam. Cole em um campo de texto simples e confira antes.




## 3. Valor com vírgula


O campo 54 (valor) usa ponto decimal. O Manual do BR Code dá como exemplos 0, 1.00 e 123.99, com tamanho de 1 a 13 caracteres. Sem separador de milhar e sem símbolo de moeda.


Teste real: gerei o mesmo código com valor 123,45 e CRC recalculado corretamente (7B9E). O CRC bateu, mas o decodificador avisou "Valor em formato inválido (use ponto decimal, até 2 casas)". Esse caso é típico de planilha ou ERP que monta o código por concatenação de texto: o formato brasileiro do número vai direto para o campo.


Detalhe importante: aqui o CRC está certo e o código continua inválido. Por isso não basta conferir só o CRC.




## 4. Nome e cidade acima do limite


Pelo Manual do BR Code, o nome do recebedor (campo 59) tem de 1 a 25 caracteres, e a cidade (campo 60) de 1 a 15. Razões sociais completas passam disso com facilidade.


Teste real: usei o nome EMPRESA DE COMERCIO E SERVICOS LTDA (35 caracteres) e a cidade SAO BERNARDO DO CAMPO (21 caracteres). O CRC estava correto, e o decodificador apontou os dois campos: "Nome do recebedor com mais de 25 caracteres" e "Cidade com mais de 15 caracteres".




- Solução: abrevie no gerador (EMPRESA COMERCIO SERV LTDA, S B DO CAMPO). Esses campos são exigidos pelo padrão, mas, no PIX, o nome mostrado ao pagador vem da consulta à chave, conforme nota do Manual de Padrões para Iniciação do Pix. Mesmo assim, os campos devem respeitar o limite: aplicativos e bibliotecas costumam validar o código inteiro antes de consultar a chave.
- O nome e a cidade não podem faltar: o decodificador avisa se os campos 59 ou 60 não existirem.




## 5. Caracteres fora do padrão


O Manual do BR Code diz que o formato usa apenas caracteres alfanuméricos: letras de A a Z (somente maiúsculas), dígitos de 0 a 9, os símbolos $ % * + - . / : e o espaço. Acentos e cedilha não fazem parte.


Teste real: com o nome JOSÉ DA SILVA e a cidade SÃO PAULO, o CRC bate (4052), mas o decodificador avisa que há caracteres fora do ASCII e que alguns aplicativos recusam. Outro risco é de implementação: se o sistema que gera o código conta o tamanho do campo de um jeito (caracteres) e o aplicativo que lê de outro (bytes), um acento muda a conta e o campo deixa de bater com o tamanho declarado. Isso é uma hipótese comum a verificar, não uma regra do manual.


Um ponto a conferir na fonte: o manual do BR Code lista só letras maiúsculas, mas os exemplos do Manual de Padrões para Iniciação do Pix usam nomes com minúsculas (Fulano de Tal). Se o código só falha em um aplicativo específico, converter tudo para maiúsculas e sem acento é a precaução mais simples.




## 6. PIX de uso único ou dinâmico vencido


Dois casos diferentes, ambos com código "válido" na forma:




- Uso único. Pelo Manual do BR Code, o campo 01 (ponto de iniciação) com valor 12 significa que o código só pode ser usado uma vez. Depois do primeiro pagamento, uma segunda tentativa deve ser recusada.
- Dinâmico (cobrança). O código carrega uma URL (subcampo 25 do campo 26 a 51) e o aplicativo consulta o banco do recebedor para saber valor, beneficiário e situação. Na cobrança imediata, o prazo é o campo calendario.expiracao, em segundos, e, se ele não for informado, vale 86400 segundos (24 horas) a partir da criação. Cobranças concluídas, expiradas ou removidas podem receber resposta HTTP como 410 ou 404, a critério do banco do recebedor.


Limite do decodificador: ele lê apenas o texto do código, sem consultar a URL. Ele mostra que o código é dinâmico e qual é a URL, mas não sabe se a cobrança expirou ou foi paga. Nesses casos, a confirmação é com quem emitiu: peça um novo código.




## Roteiro rápido de diagnóstico




- Cole o código inteiro no decodificador de PIX (https://meajudaflow.com.br/tools/pix). Se ele recusar logo de início, o texto não começa em 000201.
- Veja o CRC: se "não confere", o código foi alterado ou cortado. Peça outro.

- Se o CRC bate, leia os avisos: valor, nome, cidade, caracteres.
- Confira o tipo: estático ou dinâmico. Em dinâmico, o problema pode estar na cobrança, e não no texto.

- Se nada aparece e o banco ainda recusa, confirme com o recebedor se a chave existe e está ativa. Isso o decodificador não consegue verificar.




## Para quem gera o código por sistema


Se o seu ERP ou planilha monta o PIX por conta própria, três regras evitam a maior parte das recusas: formatar o valor com ponto e duas casas; limitar nome a 25 e cidade a 15 caracteres, sem acento; e calcular o CRC sobre o texto completo, por último. Depois de gerar, passe o código pelo decodificador antes de enviar ao cliente.


Para decodificar um código campo a campo e ver o CRC informado e o calculado, use a ferramenta PIX copia e cola (https://meajudaflow.com.br/tools/pix) do Me Ajuda Flow. Se o pagamento for por boleto, a ferramenta de boleto (https://meajudaflow.com.br/tools/boleto) faz a mesma verificação com a linha digitável. Para conferir o CPF ou CNPJ de quem recebe, veja CPF e CNPJ (https://meajudaflow.com.br/tools/cpf-cnpj).

Fontes oficiais:
- Manual do BR Code (Banco Central do Brasil): https://www.bcb.gov.br/content/estabilidadefinanceira/ativosdosite/Manual%20do%20BR%20Code.pdf
- Manual de Padrões para Iniciação do Pix (Banco Central do Brasil): https://www.bcb.gov.br/content/estabilidadefinanceira/pix/Regulamento_Pix/II_ManualdePadroesparaIniciacaodoPix.pdf

## Como ler a linha digitável do boleto

URL: https://meajudaflow.com.br/guias/como-ler-linha-digitavel-do-boleto
Atualizado em: 2026-11-02

A linha digitável de 47 dígitos e o código de barras de 44 carregam as mesmas informações em ordens diferentes. Veja onde estão o banco, o valor e o vencimento, como os dígitos verificadores funcionam, o que mudou no fator de vencimento em 22/02/2025 e por que o boleto de 48 dígitos é outra coisa.

## Duas representações do mesmo dado


Todo boleto bancário (o de cobrança) tem um código de barras de 44 posições, que é o que o leitor ótico lê, e uma linha digitável de 47 dígitos, que é a mesma informação reorganizada para ser digitada ou copiada. A Convenção da FEBRABAN deixa claro que os dados da linha digitável não aparecem na mesma sequência dos do código de barras. Quem desenvolve ou concilia pagamentos precisa saber converter entre os dois.




## O código de barras de 44 posições




- Posições 1 a 3: código do banco destinatário.
- Posição 4: código da moeda. O 9 indica real.

- Posição 5: dígito verificador (DV) geral do código de barras, calculado em módulo 11.
- Posições 6 a 9: fator de vencimento (4 dígitos).

- Posições 10 a 19: valor, 10 dígitos, em centavos, sem vírgula.
- Posições 20 a 44: campo livre, 25 dígitos. Cada banco define o conteúdo (agência, conta, carteira, nosso número etc.).




## A linha digitável de 47 dígitos


Ela é dividida em cinco campos. Os três primeiros terminam com um DV próprio em módulo 10; o quarto é só o DV geral; o quinto junta fator e valor.




- Campo 1: banco (3) + moeda (1) + posições 20 a 24 do código de barras + DV do campo.
- Campo 2: posições 25 a 34 + DV do campo.

- Campo 3: posições 35 a 44 + DV do campo.
- Campo 4: o DV geral (posição 5 do código de barras).

- Campo 5: fator de vencimento (4) + valor (10).




## Exemplo real, dígito a dígito


Este é o exemplo clássico da documentação de cobrança, calculado com o código do Me Ajuda Flow. A linha digitável é:



```
00190.50095 40144.816069 06809.350314 3 37370000000100
```




- Campo 1, 00190.50095: banco 001 (Banco do Brasil), moeda 9, início do campo livre 05009, DV 5.
- Campo 2, 40144.816069: 4014481606 e DV 9.

- Campo 3, 06809.350314: 0680935031 e DV 4.
- Campo 4: 3, o DV geral.

- Campo 5, 37370000000100: fator 3737 e valor 0000000100, ou seja, R$ 1,00.


Montando o código de barras de 44 dígitos na ordem correta (banco, moeda, DV geral, fator, valor, campo livre), o resultado é:



```
00193373700000001000500940144816060680935031
```


O campo livre é a concatenação das posições 20 a 44: 0500940144816060680935031. O fator 3737 corresponde a 31/12/2007, e os três DVs de campo e o DV geral conferem.




## Como os DVs funcionam


Os DVs de campo (módulo 10) servem para detectar erro de digitação dentro de cada bloco: você digita o campo 2 errado e o DV acusa. O DV geral (módulo 11) confere o código de barras inteiro. Por isso um erro de digitação é apontado pelo campo, e não só no final. No módulo 10 os dígitos são multiplicados alternadamente por 2 e 1, da direita para a esquerda, e os algarismos dos produtos são somados. Para 001905009 o DV é 5, e para 4014481606 é 9. Confirme os detalhes do cálculo na Convenção da FEBRABAN antes de implementar do zero.




## Fator de vencimento e a reinicialização de 22/02/2025


O fator de vencimento é um contador de dias com 4 dígitos, que entrou no código de barras pela Carta-Circular 2926 do Banco Central, com validade a partir de 1º de setembro de 2000. A mesma norma diz que 0000 nesse campo indica que o código de barras não contém fator de vencimento.


A contagem parte de 07/10/1997. Ao chegar em 9999, em 21/02/2025, ela foi reiniciada em 1000 a partir de 22/02/2025, conforme comunicado da FEBRABAN divulgado pelo mercado. Com o código do Me Ajuda Flow:




- Fator 9999 = 21/02/2025.
- Fator 1000 = 22/02/2025 (e, no ciclo antigo, 03/07/2000).

- Fator 1001 = 23/02/2025.
- Fator 1002 = 24/02/2025.


Consequência prática: o mesmo número pode significar duas datas, uma de cada ciclo. O fator 3737 do exemplo acima é 31/12/2007 no ciclo antigo, e seria 21/08/2032 no novo. Um sistema que lê boletos precisa decidir qual ciclo usar, em geral o mais próximo da data de hoje, e mostrar a data para conferência humana. O ciclo novo vai de 1000 até 9999 de novo, o que dá 9.000 dias: o próximo limite é por volta de 13/10/2049.


Atenção: não consegui abrir o comunicado original da FEBRABAN sobre a reinicialização; a regra acima vem do cálculo do código do projeto e de fornecedores que citam o comunicado. Se você vai alterar uma regra de validação em produção, confirme o texto oficial com o seu banco ou com a FEBRABAN.




## Boleto de convênio e arrecadação: 48 dígitos


Contas de consumo (água, luz, telefone) e tributos usam outro padrão. A linha tem 48 dígitos, em quatro blocos de 11 dígitos, cada um seguido do seu próprio DV, e o código começa com 8. Esse formato não segue o leiaute banco, moeda e campo livre. Pelo que o decodificador do Me Ajuda Flow implementa, o início identifica o produto e o segmento (por exemplo, energia elétrica e gás), o valor e o tipo de DV, e o restante identifica a empresa ou órgão e o documento; confirme na convenção de arrecadação. Um código de barras de convênio também tem 44 dígitos, mas não é um boleto bancário, e tratá-lo como tal gera erro.


Exemplo gerado pelo código do Me Ajuda Flow, com dados fictícios: a linha 836900000016 234512345674 812345678906 000000000000 (48 dígitos, sem pontos) tem o código de barras de 44 dígitos 83690000001234512345678123456789000000000000 e valor de R$ 123,45 (segmento 3, energia elétrica e gás). O leiaute completo desse padrão pertence a outra convenção, que não abri aqui: use a documentação da FEBRABAN para o convênio quando precisar de todos os campos.




## Checklist de validação




- Conte os dígitos: 47 (cobrança), 48 (convênio) ou 44 (código de barras).
- Se começa com 8 e tem 44 ou 48 dígitos, é convênio, não cobrança.

- Confira os três DVs de campo e o DV geral.
- Leia o valor dos 10 últimos dígitos e divida por 100. Valor zero merece atenção: confirme com o emissor se o valor é variável.

- Se o fator for 0000, não há vencimento no código. Se não, converta o fator e confira a data.


Para fazer essa decodificação sem escrever código, cole a linha na ferramenta de boleto (https://meajudaflow.com.br/tools/boleto) do Me Ajuda Flow: ela separa os campos, confere os DVs e mostra o vencimento. Para o equivalente do Pix, veja o decodificador de Pix (https://meajudaflow.com.br/tools/pix); para conferir datas, a calculadora de datas (https://meajudaflow.com.br/tools/datas).

Fontes oficiais:
- Carta-Circular 2926/2000 (Banco Central do Brasil): inclui o fator de vencimento no código de barras: https://www.bcb.gov.br/pre/normativos/c_circ/2000/pdf/c_circ_2926_v1_o.pdf
- Convenção entre Instituições do Sistema Financeiro, boleto de pagamento, Anexo V: leiaute do código de barras e da linha digitável (FEBRABAN): https://cmsarquivos.febraban.org.br/Arquivos/documentos/PDF/Conven%C3%A7%C3%A3o%20da%20Cobran%C3%A7a%20-%2005_02_2021_f.pdf

## Como conferir a chave de acesso da NF-e

URL: https://meajudaflow.com.br/guias/como-conferir-chave-de-acesso-da-nfe
Atualizado em: 2026-11-02

A chave de 44 dígitos identifica a nota e carrega vários dados do emitente. Dá para ler cada bloco e recalcular o dígito verificador sem consultar ninguém. O que isso não dá é prova de que a nota existe ou foi autorizada.

## O que é a chave de acesso

Segundo o Manual de Orientação ao Contribuinte (MOC 7.0), a chave de acesso é um conjunto de 44 caracteres numéricos, formado pela concatenação de campos do próprio leiaute da NF-e. Ela aparece no DANFE, em geral agrupada de quatro em quatro dígitos, e é o identificador usado para consultar a nota. O mesmo formato de 44 posições vale para a NFC-e (modelo 65).

## Os blocos da chave, posição por posição

A estrutura da versão 4.00 do leiaute, conforme a Tabela 2-1 do MOC, é esta:

- Posições 1 e 2: cUF. Código da UF do emitente (35 é São Paulo, por exemplo).
- Posições 3 a 6: AAMM. Ano e mês de emissão. "2610" é outubro de 2026.

- Posições 7 a 20: CNPJ/CPF do emitente, 14 caracteres. Para emitente pessoa física, o CPF vem precedido de zeros até completar 14.
- Posições 21 e 22: modelo. 55 para NF-e, 65 para NFC-e.

- Posições 23 a 25: série. Três dígitos. O MOC reserva faixas de série (Tabela 2-4), inclusive 910 a 969 para emitente pessoa física.
- Posições 26 a 34: número da nota (nNF), nove dígitos com zeros à esquerda.

- Posição 35: tpEmis. Forma de emissão (1 é emissão normal).
- Posições 36 a 43: cNF. Código numérico de oito dígitos. É o único campo que não pode ser deduzido por terceiros, e por isso deve ser uma sequência totalmente aleatória.

- Posição 44: cDV. Dígito verificador.

O MOC 7.0 descreve a chave como numérica. Se o seu sistema receber chaves de emitentes com CNPJ alfanumérico, confira na versão vigente do manual como o campo é tratado.

## O dígito verificador, módulo 11

O MOC explica que o DV protege a chave principalmente contra erros de digitação. O cálculo:

- Pegue os 43 primeiros dígitos.
- Multiplique cada um pela sequência 2, 3, 4, 5, 6, 7, 8, 9, 2, 3... posicionada da direita para a esquerda.

- Some os produtos e divida a soma por 11.
- DV = 11 menos o resto da divisão. Se o resto for 0 ou 1, o DV é 0.

### Exemplo numérico

Chave fictícia montada com o código do Me Ajuda Flow, emitente 11.222.333/0001-81 (CNPJ de exemplo), São Paulo, outubro de 2026, modelo 55, série 1, nota 5678:

```
35 | 2610 | 11222333000181 | 55 | 001 | 000005678 | 1 | 87654321 | 5
35261011222333000181550010000056781876543215
```

A soma ponderada dos 43 primeiros dígitos é 655. Dividindo por 11, o resto é 6, e o DV é 11 - 6 = 5, igual ao último dígito da chave. Se alguém digitar o penúltimo dígito errado (...3225 no lugar de ...3215), o resto passa a ser 8, o DV esperado vira 3 e a conferência acusa divergência.

Como controle, a ferramenta reproduz o exemplo do próprio MOC: os 43 dígitos 5206043300991100250655012000000780026730161 dão DV 5, o mesmo valor do manual.

### Um limite do módulo 11

Trocar dois dígitos vizinhos nem sempre é detectado. Na chave fictícia da nota 1234, o DV é 0 (soma 583, resto 0). Trocando "12" por "21" no número da nota, a soma vai a 584, o resto a 1, e o DV continua 0: a chave adulterada passa na conferência. Isso é coincidência do caso "resto 0 ou 1", mas mostra que o DV é rede de proteção contra digitação, não selo de integridade.

## O que a conferência NÃO prova

- Existência: uma chave com DV correto pode nunca ter sido emitida. Qualquer pessoa consegue montar uma chave coerente.
- Autorização de uso: só a SEFAZ confirma que a NF-e foi autorizada. Para isso é preciso consultar o Ambiente Nacional ou a SEFAZ autorizadora.

- Situação atual: cancelamento e outros eventos não aparecem na chave.
- Valor e itens: a chave não traz valor, produtos nem impostos.

Pelo MOC, a consulta por chave a partir de um sistema exige chave válida, existente no Ambiente Nacional e vinculada ao interessado como destinatário, transportador ou terceiro. Para o destinatário, sem manifestação registrada, retorna só o resumo da NF-e. O Portal Nacional da NF-e tem a opção "Consultar NF-e" para a consulta pontual.

## Uso na conciliação de pagamentos

- Triagem de digitação: antes de lançar o pagamento, recalcule o DV. Chave que não confere é erro de digitação ou de leitura do código de barras, e custa segundos corrigir.
- Emitente contra o cadastro: extraia o CNPJ das posições 7 a 20 e compare com o fornecedor do pedido. Nota de outro CNPJ para o mesmo fornecedor merece pergunta.

- Duplicidade: a chave é única por nota. Use-a como identificador para achar a mesma nota lançada duas vezes.
- Competência: o AAMM dá o mês de emissão, útil para conferir se a nota pertence ao período.

- Existência e valor: continuam dependendo da consulta à SEFAZ e do XML. O valor da nota e o do boleto precisam ser cruzados por outro caminho.

Para decodificar uma chave e ver os blocos e o dígito verificador sem enviar nada a servidor, use a ferramenta de chave de NF-e (https://meajudaflow.com.br/tools/nfe). O CNPJ extraído pode ser validado no validador de CPF e CNPJ (https://meajudaflow.com.br/tools/cpf-cnpj), e o boleto relacionado, no leitor de boleto (https://meajudaflow.com.br/tools/boleto).

Fontes oficiais:
- Manual de Orientação ao Contribuinte (MOC) 7.0, Visão Geral, item 2.2.6 (Portal Nacional da NF-e): https://www.nfe.fazenda.gov.br/portal/exibirArquivo.aspx?conteudo=LrBx7WT9PuA=
- Manuais da NF-e (Portal Nacional da NF-e): https://www.nfe.fazenda.gov.br/portal/listaConteudo.aspx?tipoConteudo=ndIjl+iEFdE=
- Portal da Nota Fiscal Eletrônica (consulta de NF-e): https://www.nfe.fazenda.gov.br/portal/principal.aspx

## CNPJ alfanumérico: o que muda no seu sistema

URL: https://meajudaflow.com.br/guias/cnpj-alfanumerico-o-que-muda-no-seu-sistema
Atualizado em: 2026-11-02

O CNPJ continua com 14 posições, mas as 12 primeiras podem ter letras. Quem trata o CNPJ como número, em banco, planilha ou fluxo, precisa revisar o campo e a validação. Veja o que é oficial, como o dígito verificador é calculado e uma lista prática do que checar.

## O que é e por que existe

A Receita Federal informa que o motivo da mudança é o iminente esgotamento dos números de CNPJ disponíveis, com o número de empresas continuando a crescer. A base legal indicada na página oficial é a Instrução Normativa RFB nº 2.229, publicada em 15 de outubro de 2024 e em vigor desde 25 de outubro de 2024.

O CNPJ alfanumérico é atribuído exclusivamente a novas inscrições, a partir de julho de 2026. Quem já está inscrito mantém o número atual, que continua válido, e não precisa fazer atualização cadastral por causa da mudança. Segundo o Serpro, os sistemas adaptados entraram em produção em 27 de julho de 2026 e o primeiro CNPJ alfanumérico foi emitido em 31 de julho, com liberação progressiva. O solicitante não escolhe o formato. Na prática, os dois formatos vão conviver, e seu sistema precisa aceitar ambos.

## Como fica o formato

- Continuam 14 caracteres e a mesma máscara: AA.AAA.AAA/AAAA-DD.
- As 12 primeiras posições podem ter dígitos (0 a 9) ou letras maiúsculas (A a Z). Isso inclui a raiz de 8 caracteres e a ordem do estabelecimento, os 4 caracteres depois da barra.

- Os 2 dígitos verificadores continuam numéricos.

Exemplo de CNPJ alfanumérico bem formado: 12.ABC.345/01DE-35.

## Como o dígito verificador é calculado

O método é o módulo 11 que já existia, com uma adaptação: cada caractere é convertido no seu valor ASCII menos 48. Com isso, os dígitos de 0 a 9 valem o próprio número (o ASCII de "0" é 48), e as letras passam a valer a partir de 17: A vale 17, B vale 18, e assim até Z, que vale 42.

- Pegue os 12 primeiros caracteres e converta cada um (ASCII menos 48).
- Multiplique, da direita para a esquerda, pelos pesos 2, 3, 4, 5, 6, 7, 8, 9, e depois recomece em 2.

- Some os produtos e calcule o resto da divisão por 11.
- Se o resto for 0 ou 1, o dígito é 0. Caso contrário, o dígito é 11 menos o resto.

- Para o segundo dígito, repita com 13 caracteres (os 12 mais o primeiro dígito).

### Exemplo conferido

Para a base 12ABC34501DE, o cálculo com o código do Me Ajuda Flow deu:

- Primeira soma: 459. Resto por 11: 8. Primeiro dígito: 11 - 8 = 3.
- Segunda soma, com a base 12ABC34501DE3: 424. Resto por 11: 6. Segundo dígito: 11 - 6 = 5.

- Resultado: 12.ABC.345/01DE-35. Trocando o final para -36, o validador recusa com "Dígitos verificadores não conferem (esperado 35)".

O CNPJ numérico 11.222.333/0001-81 segue passando pela mesma regra, porque para dígitos o ASCII menos 48 é o próprio valor. Isso é o que permite uma única rotina para os dois formatos. O documento oficial de cálculo está na página da Receita; antes de levar isso para produção, confira lá os pesos e o exemplo.

## O que revisar no seu ambiente

O Serpro orienta a avaliar aplicações, cadastros, bancos de dados e integrações que tratem o CNPJ apenas como campo numérico, e a revisar as rotinas de validação para aceitar os dois formatos.

### Bancos de dados

- Coluna BIGINT ou NUMERIC para CNPJ não aceita letras. Use texto de 14 caracteres (CHAR(14) ou VARCHAR(14)), sem máscara.
- Chaves estrangeiras e índices que usam o CNPJ precisam acompanhar o tipo novo.

- Ordenação e comparação passam a ser de texto. Padronize em maiúsculas antes de gravar.

### Planilhas

- Formate a coluna como Texto antes de colar CNPJs. O Excel trata um CNPJ só com dígitos como número e pode perder zeros à esquerda; um valor como 12345E67 corre o risco de ser lido como notação científica.
- Fórmulas como --A2 ou VALOR(A2) sobre o CNPJ deixam de funcionar para os novos números.

- Importações de CSV: peça ao Excel para ler a coluna como texto.

### Power Automate

- Variáveis e parâmetros devem ser String, não Integer.
- Para normalizar a entrada, tire a máscara e coloque em maiúsculas:

```
toUpper(replace(replace(replace(triggerBody()?['cnpj'], '.', ''), '/', ''), '-', ''))
```

- Depois da normalização, confira equals(length(...), 14). Não use int() nem float() no CNPJ.
- Para validar o dígito, use uma função própria (Azure Function, Office Script ou conector de validação). Calcular o módulo 11 só com expressões é possível, mas longo e difícil de manter.

### Validações e telas

- Remova máscaras e regex que aceitam só \d. Troque por [0-9A-Z] nas 12 primeiras posições e [0-9] nas duas últimas.
- Campos de entrada: inputmode numérico não deve ser usado, porque o teclado do celular não mostra letras.

- Cuidado com validações antigas que rejeitam o CNPJ quando o DV não bate: elas precisam usar o cálculo novo, senão recusam CNPJs legítimos.

### Integrações e documentos fiscais

- APIs, arquivos de layout (remessa, SPED, importação em ERP) e contratos de integração que definem CNPJ como numérico precisam ser revisados com cada parceiro.
- A chave de acesso de 44 posições da NF-e carrega o CNPJ do emitente. A Receita e os demais órgãos publicaram notas técnicas sobre o impacto nos documentos fiscais eletrônicos: confira a nota vigente do seu documento antes de alterar o seu validador.

## Como testar sem inventar CNPJ

A Receita Federal disponibiliza um simulador que gera CNPJs alfanuméricos para teste, citado pelo Serpro. Use-o ou um gerador de testes para checar se o seu fluxo grava, valida e devolve o CNPJ sem alterar nada. Teste também um CNPJ numérico, uma letra minúscula (que sua entrada deve normalizar) e um valor com DV errado, que deve ser recusado.

## Checklist rápido

- Liste onde o CNPJ aparece: bancos, planilhas, fluxos, APIs, relatórios.
- Troque campos numéricos por texto de 14 caracteres.

- Normalize: sem máscara, em maiúsculas.
- Atualize a validação do dígito para ASCII menos 48.

- Teste com casos alfanuméricos, numéricos e inválidos.

Para conferir um CNPJ, numérico ou alfanumérico, e ver o cálculo dos dígitos, use a ferramenta validador de CPF e CNPJ (https://meajudaflow.com.br/tools/cpf-cnpj). Se o CNPJ vier dentro de uma chave de 44 dígitos, o decodificador de chave de NF-e (https://meajudaflow.com.br/tools/nfe) separa o emitente.

Fontes oficiais:
- CNPJ Alfanumérico (Receita Federal, gov.br): https://www.gov.br/receitafederal/pt-br/acesso-a-informacao/acoes-e-programas/programas-e-atividades/cnpj-alfanumerico
- CNPJ alfanumérico: o que muda para empresas e empreendedores (Serpro): https://www.serpro.gov.br/menu/noticias/noticias-2026/cnpj-alfanumerico-o-que-muda

## Valor por extenso em reais: regras para contratos, recibos e cheques

URL: https://meajudaflow.com.br/guias/valor-por-extenso-em-contratos-e-recibos
Atualizado em: 2026-11-02

O valor por extenso é a parte do documento que ninguém revisa e que mais gera divergência com os algarismos. Veja as regras de escrita, os erros que se repetem e uma forma simples de conferir antes de assinar.

## Por que o extenso importa

Em contratos, recibos e cheques, o valor aparece duas vezes: em algarismos e por extenso. A ideia é uma conferir a outra. Quando as duas divergem, o documento passa a ter um problema, e quem resolve a divergência já não é você. Por isso vale escrever com cuidado e conferir com método.

Aviso: este guia trata de escrita e conferência. Não é aconselhamento jurídico. Para contratos relevantes, valide o texto com quem responde por ele na sua empresa.

## Regra 1: reais, centavos e o conectivo e

A parte inteira leva real (singular só para um) ou reais. Os centavos vêm depois, ligados por e. A mesma lógica de singular e plural vale para centavo e centavos.

- 1,00: um real
- 0,01: um centavo

- 1,50: um real e cinquenta centavos
- 21,00: vinte e um reais

Zero reais com centavos escreve-se só com os centavos ("um centavo"), como a ferramenta faz.

## Regra 2: cem e cento

Cem é só o número cem, exato. A partir de 101, usa-se cento. Exemplos conferidos na ferramenta de valor por extenso (https://meajudaflow.com.br/tools/extenso):

```
100     -> cem reais
101     -> cento e um reais
101000  -> cento e um mil reais
100000  -> cem mil reais
```

Erro frequente: escrever "cem e um reais" ou "cento reais".

## Regra 3: o e entre as classes

O e liga dezenas e unidades (vinte e um) e centenas a dezenas (cento e dez). Entre as classes (milhar, centena), a convenção usada pela ferramenta é pôr o e só quando o bloco final é uma centena exata ou tem menos de cem (mil e cem, mil e um); nos demais casos o e não entra entre as classes. Veja o que a ferramenta produz:

```
1001     -> mil e um reais
1100     -> mil e cem reais
1234,56  -> mil duzentos e trinta e quatro reais e cinquenta e seis centavos
2500003  -> dois milhões quinhentos mil e três reais
```

Note o contraste: 1.100 leva "e" (mil e cem), 1.234 não leva entre mil e duzentos (mil duzentos e trinta e quatro). Existem variações de estilo, e alguns manuais escrevem de forma diferente; se o seu modelo de contrato exige um padrão, siga o do modelo e use o mesmo em todo o documento.

## Regra 4: mil nunca é "um mil"

O valor 1.000 é mil reais, não "um mil reais". A partir de 2.000 o numeral vem antes: dois mil, vinte e um mil. O plural de milhão muda: um milhão, dois milhões.

## Regra 5: o "de reais" nos milhões e bilhões

Quando o valor é exatamente milhões ou bilhões, sem milhares ou unidades depois, a convenção é usar de antes de reais. Se há complemento, o "de" some:

```
1000000     -> um milhão de reais
2000000,50  -> dois milhões de reais e cinquenta centavos
1000001     -> um milhão e um reais
1100000     -> um milhão e cem mil reais
```

Esse é o ponto em que mais gente erra, porque "um milhão e um reais" soa estranho. Se o texto for usado em documento formal, confirme a convenção adotada pela sua área.

## O que a lei diz sobre divergência

Em cheque, a Lei do Cheque (Lei 7.357/1985, art. 12) diz que, feita a indicação da quantia em algarismos e por extenso, prevalece esta no caso de divergência, isto é, o extenso. E se a quantia for indicada mais de uma vez, por extenso ou por algarismos, prevalece a menor quantia. Confira o texto na fonte.

Para recibos, o Código Civil (art. 320) diz que a quitação deve designar o valor e a espécie da dívida quitada, o nome do devedor, o tempo e o lugar do pagamento, com a assinatura do credor. Este guia não afirma qual regra vale em contratos em geral: isso depende do tipo de documento e deve ser confirmado com o responsável jurídico.

## Erros comuns, em uma lista

- "Um mil reais" em vez de "mil reais".
- "Cem e um" ou "cento" para 100 exato.

- Esquecer o plural: "dois real", "cinquenta centavo".
- Escrever centavos em algarismos misturados: "dois reais e 50 centavos".

- Trocar o valor ao revisar o contrato: mudar os algarismos e esquecer o extenso (ou o contrário).
- Deixar espaço em branco depois do extenso em documentos manuscritos, o que facilita acréscimos. Preencha a linha até o fim.

## Exemplo completo, calculado

Parcela de contrato de R$ 12.480,05:

```
12480,05 -> doze mil quatrocentos e oitenta reais e cinco centavos
```

Passo a passo: 12.000 vira "doze mil"; 480 vira "quatrocentos e oitenta" (o e liga centena a dezena); os cinco centavos vêm depois de "reais e". Uma conferência rápida: leia o extenso em voz alta e escreva o número que ouviu. Se der 12.480,05, bateu.

## Método de conferência

- Digite o valor em algarismos na ferramenta, no formato brasileiro (1.234,56).
- Compare o extenso gerado com o do documento, palavra por palavra.

- Em contratos parcelados, confira também a soma das parcelas na calculadora de parcelas (https://meajudaflow.com.br/tools/parcelas), porque o resto de centavos costuma cair na última.
- Se o valor veio de planilha, cheque o formato do número com o conversor de números BR (https://meajudaflow.com.br/tools/numero-br) antes de gerar o texto.

Para gerar e conferir o valor por extenso em reais, use a ferramenta Valor por extenso (https://meajudaflow.com.br/tools/extenso): roda no navegador e aceita o valor no formato brasileiro.

Fontes oficiais:
- Lei nº 7.357/1985, Lei do Cheque (Planalto): https://www.planalto.gov.br/ccivil_03/leis/l7357.htm
- Lei nº 10.406/2002, Código Civil, arts. 319 e 320 (Planalto): https://www.planalto.gov.br/ccivil_03/leis/2002/l10406compilada.htm

## PROCV, PROCX ou ÍNDICE+CORRESP: qual usar

URL: https://meajudaflow.com.br/guias/excel-procv-procx-indice-corresp-qual-usar
Atualizado em: 2026-11-02

As três formas buscam um valor em uma tabela e devolvem outro da mesma linha. A diferença está na direção da busca, no que acontece quando você mexe nas colunas e em quais versões do Excel abrem o arquivo sem erro.

## Resposta curta

- PROCX: a melhor escolha quando todos os usuários do arquivo têm Excel para Microsoft 365, 2021 ou 2024.
- ÍNDICE + CORRESP: a alternativa que funciona em qualquer direção e em versões sem PROCX.

- PROCV: serve para tabelas simples, com a chave na primeira coluna, desde que você lembre de usar FALSO no último argumento.

## PROCV: o que ele faz e onde machuca

Sintaxe oficial em português:

```
=PROCV(valor_procurado; matriz_tabela; núm_índice_coluna; [intervalo_pesquisa])
```

Três limitações explicam a maioria dos erros em planilhas:

- Só busca para a direita. O valor procurado precisa estar na primeira coluna de matriz_tabela, e o resultado, em uma coluna à direita dela.
- O índice da coluna é um número fixo. núm_índice_coluna conta a partir da coluna mais à esquerda da matriz. Se alguém inserir ou apagar uma coluna dentro do intervalo, o número deixa de apontar para a coluna que você queria, e a fórmula pode devolver o dado errado sem avisar.

- A correspondência padrão é aproximada. Se você omitir o quarto argumento, ele vale VERDADEIRO, e a primeira coluna precisa estar em ordem crescente. Com FALSO a busca é exata.

Hábito seguro: escreva sempre o quarto argumento. Para códigos, nomes e CNPJs, use FALSO (ou 0).

## PROCX: o que muda

```
=PROCX(valor_procurado; matriz_procurada; matriz_retorno; [se_não_encontrada]; [modo_correspondência]; [modo_pesquisa])
```

- Duas colunas separadas: você aponta a coluna onde procura e a coluna de onde devolve. Não há número de índice para quebrar, e a coluna de retorno pode ficar à esquerda da de busca.
- Exata por padrão: modo_correspondência vale 0. Os demais valores são -1 (exata ou o próximo menor), 1 (exata ou o próximo maior) e 2 (curingas *, ? e ~).

- Tratamento de ausência embutido: se_não_encontrada substitui o #N/D sem precisar de SEERRO.
- Direção da busca: modo_pesquisa -1 procura do último para o primeiro item, útil para achar o lançamento mais recente de uma chave repetida.

- Várias colunas de uma vez: se matriz_retorno tiver mais de uma coluna, o resultado se espalha ao lado. A página oficial mostra um exemplo que devolve nome e departamento em uma única fórmula.

## ÍNDICE + CORRESP: o par que sempre funcionou

O CORRESP devolve a posição de um valor em um intervalo, e o ÍNDICE devolve o valor que está em uma posição.

```
=ÍNDICE(matriz; núm_linha; [núm_coluna])
=CORRESP(valor_procurado; matriz_procurada; [tipo_correspondência])
```

No CORRESP, o tipo_correspondência omitido vale 1 (maior valor menor ou igual, exige ordem crescente). Use 0 para exata, que aceita qualquer ordem. O valor -1 exige ordem decrescente.

Juntas, as duas permitem buscar em qualquer direção, e a Microsoft as indica quando a chave não está à esquerda do resultado. Como você aponta intervalos inteiros, inserir uma coluna no meio da tabela não desloca o resultado.

## Exemplo prático

Tabela com o código na coluna B (B2:B4: P-100, P-200, P-300) e o preço na coluna A (A2:A4). Queremos o preço do produto P-200, que está à esquerda do código.

- PROCV: não alcança, porque a coluna de retorno está à esquerda.
- PROCX: =PROCX("P-200"; B2:B4; A2:A4; "Não achei").

- ÍNDICE+CORRESP: =ÍNDICE(A2:A4; CORRESP("P-200"; B2:B4; 0)). O CORRESP devolve 2, e o ÍNDICE devolve a segunda célula de A2:A4. Para P-999, o CORRESP devolve #N/D, pois o código não existe.

Caso de correspondência aproximada, uma faixa de comissão: 0 a 4.999,99 paga 2%, de 5.000 a 9.999,99 paga 3%, a partir de 10.000 paga 5%. Para uma venda de R$ 7.800, a busca aproximada cai na faixa que começa em 5.000, ou seja, 3%, e a comissão é R$ 234,00. Para R$ 10.000 exatos, a faixa é 5%. Aqui a busca aproximada é o que se quer: no PROCV, VERDADEIRO com a tabela em ordem crescente; no PROCX, modo_correspondência -1.

## Compatibilidade de versões

- PROCV, ÍNDICE e CORRESP existem há muito tempo e funcionam em qualquer versão em uso.
- PROCX chegou ao Excel para Microsoft 365 e ao Excel 2021 e 2024. A página oficial traz uma nota informando que ele não está disponível no Excel 2016 e no Excel 2019, embora essas versões apareçam na lista "Aplica-se a". Em caso de dúvida, trate 2016 e 2019 como sem PROCX e teste no Excel de cada pessoa.

- Se um colega com Excel 2019 abrir uma pasta de trabalho com PROCX criada por outra pessoa, a fórmula não calcula. Se o arquivo circula fora da sua equipe, prefira ÍNDICE+CORRESP.

Com a mesma lógica do PROCX, o CORRESP tem um sucessor, o CORRESPX, também disponível a partir do Excel 2021.

## Desempenho

Não há na documentação oficial consultada uma comparação de velocidade entre as três. Em planilhas grandes, a regra prática é limitar os intervalos ao que você precisa (evitar colunas inteiras desnecessárias em milhares de fórmulas) e medir no seu arquivo antes de reescrever tudo. Não troque fórmulas que funcionam só por suposição de ganho.

## Erro #N/D: causas e tratamento

Na documentação do Excel em português, o #N/D significa que a fórmula não encontrou o item. As causas mais comuns em pesquisas:

- O valor não existe na coluna de busca.
- Tipos diferentes: o número 1050 não é igual ao texto "1050". Padronize o formato dos dois lados.

- Espaços extras no início ou no fim. A Microsoft sugere ARRUMAR, por exemplo PROCV(D2;ARRUMAR(A2:B7);2;FALSO).
- Correspondência aproximada no PROCV (VERDADEIRO ou omitido): use FALSO. No CORRESP, use 0.

- Com VERDADEIRO, um valor menor que o menor da primeira coluna também gera #N/D.

Para tratar o erro:

- PROCX: use o quarto argumento, como em =PROCX(A2; Tabela[Código]; Tabela[Preço]; "Sem cadastro").
- PROCV e ÍNDICE+CORRESP: =SEERRO(PROCV(A2; D:E; 2; FALSO); "Sem cadastro").

Cuidado: a Microsoft alerta que trocar o #N/D por outro valor apenas esconde o erro, não o resolve. Antes de envolver a fórmula em SEERRO, confirme que ela está certa. SEERRO também esconde outros erros, como #REF!, por isso o argumento se_não_encontrada do PROCX é mais preciso.

## Dados vindos de fora

A maioria dos #N/D inexplicáveis vem de dados importados: números salvos como texto, vírgula e ponto trocados, espaços invisíveis e duplicatas. Limpe a lista e confira os números antes de montar a pesquisa. As ferramentas do Me Ajuda Flow abaixo ajudam nisso.

Relacionadas: o limpar e ordenar lista (https://meajudaflow.com.br/tools/limpar-lista) ajuda com espaços e duplicatas, o conversor de número brasileiro (https://meajudaflow.com.br/tools/numero-br) trata formatos numéricos e o conversor CSV para JSON (https://meajudaflow.com.br/tools/csv-json) ajuda a conferir o que veio de um arquivo CSV antes de colar na planilha.

Fontes oficiais:
- Função PROCV (Suporte da Microsoft): https://support.microsoft.com/pt-br/office/fun%C3%A7%C3%A3o-procv-0bbc8083-26fe-4963-8ab8-93a18ad188a1
- Função PROCX (Suporte da Microsoft): https://support.microsoft.com/pt-br/office/fun%C3%A7%C3%A3o-procx-b7fd680e-6d10-43e6-84f9-88eae8bf5929
- Função CORRESP (Suporte da Microsoft): https://support.microsoft.com/pt-br/office/fun%C3%A7%C3%A3o-corresp-e8dffd45-c762-47d6-bf89-533f4a37673a
- Função ÍNDICE (Suporte da Microsoft): https://support.microsoft.com/pt-br/office/%C3%ADndice-fun%C3%A7%C3%A3o-%C3%ADndice-a5dcf0dd-996d-40a4-a822-b56b061328bd
- Como corrigir um erro #N/D (Suporte da Microsoft): https://support.microsoft.com/pt-br/excel/how-to-correct-a-n-a-error
- Pesquisar valores com PROCV, ÍNDICE ou CORRESP (Suporte da Microsoft): https://support.microsoft.com/pt-br/office/pesquisar-valores-com-procv-%C3%ADndice-ou-corresp-68297403-7c3c-4150-9e3c-4d348188976b

## Como contar dias úteis e prazos com feriados nacionais

URL: https://meajudaflow.com.br/guias/contar-dias-uteis-e-prazos-com-feriados-nacionais
Atualizado em: 2026-11-02

Prazo de pagamento em dias úteis parece simples até aparecer um feriado, um ponto facultativo ou um feriado local. Veja o que entra no cálculo, o que não entra e o que deve ser confirmado na fonte antes de fechar uma data.

## O que é dia útil na conta mais comum

Na contagem de prazos de pagamento, entrega e vencimento, o uso corrente é: dia útil é segunda a sexta que não seja feriado. Não existe uma definição única de "dia útil" que valha para todo contexto. O que muda de um caso para outro é a lista de feriados considerada e a regra de contagem do contrato ou da norma aplicável. Por isso, antes de calcular, defina três coisas: qual é a data de partida, se ela conta, e quais feriados valem.

## Feriados nacionais fixos, com a lei de cada um

Os feriados nacionais fixos vêm de leis federais. Todas as datas abaixo foram conferidas no texto das leis no site do Planalto:

- 1º de janeiro, 1º de maio, 7 de setembro, 15 de novembro e 25 de dezembro: Lei nº 662/1949.
- 21 de abril (Tiradentes) e 2 de novembro (Finados): incluídos na Lei nº 662/1949 pela Lei nº 10.607/2002.

- 12 de outubro (Nossa Senhora Aparecida): Lei nº 6.802/1980.
- 20 de novembro: Lei nº 14.759/2023, de 21 de dezembro de 2023, que declara a data feriado nacional (Dia Nacional de Zumbi e da Consciência Negra).

### O caso do 20 de novembro

A Lei nº 14.759/2023 entra em vigor na data de sua publicação, ainda em dezembro de 2023. Na prática, o primeiro 20 de novembro como feriado nacional foi o de 2024. Se você recalcula prazos de anos anteriores, o dia 20 de novembro de 2023 não era feriado nacional por essa lei. A ferramenta do Me Ajuda Flow segue esse corte: em 2023 o dia aparece como útil, em 2024 como feriado.

## Sexta-feira Santa e Páscoa

A Páscoa muda de data a cada ano, e a Sexta-feira Santa cai dois dias antes. Em 2026 a Páscoa é 5 de abril e a Sexta-feira Santa é 3 de abril; em 2027 a Páscoa é 28 de março (valores calculados com o algoritmo da ferramenta). O calendário oficial federal de 2026 do Ministério da Gestão (MGI) lista 3 de abril, "Paixão de Cristo", entre os dez feriados nacionais do ano.

Uma sutileza que vale conhecer: a Lei nº 9.093/1995 trata os feriados religiosos como de lei municipal, em número de no máximo quatro, e cita a Sexta-Feira da Paixão dentro desse limite. Ou seja, a base legal da Sexta-feira Santa não é a mesma das datas fixas acima. Para um contrato específico, confirme se ele adota o calendário federal ou outro.

## Carnaval e Corpus Christi: ponto facultativo não é feriado

No calendário federal de 2026 do MGI, o Carnaval (16 e 17 de fevereiro), a Quarta-feira de Cinzas (18 de fevereiro, até as 14h) e Corpus Christi (4 de junho) aparecem como pontos facultativos, e não na lista de feriados nacionais. Ponto facultativo é uma decisão de funcionamento da administração federal: não cria feriado nacional para o prazo de um boleto, de um contrato ou de um pagamento entre empresas.

Isso não significa que o dia seja normal para todo mundo. Estados e municípios podem ter regras locais, empresas podem fechar, e o expediente bancário segue calendário próprio do sistema financeiro. Confirme esse calendário no Banco Central ou no seu banco, porque a fonte oficial dessa regra não pôde ser aberta e confirmada para este guia.

## O que fica fora do cálculo

- Feriados estaduais: a Lei nº 9.093/1995 prevê a data magna do Estado, fixada em lei estadual.
- Feriados municipais: o aniversário de fundação e os dias religiosos locais dependem de lei municipal.

Nenhum dos dois entra num cálculo nacional. Se o prazo depende de um local (a sede do credor, a filial, a comarca), inclua essas datas à mão. Na ferramenta Dias úteis (https://meajudaflow.com.br/tools/dias-uteis), use o campo de datas extras para isso.

## Dia útil bancário, trabalhista e de contrato

Há contextos em que a contagem muda de nome e de regra. Em direito do trabalho, a Lei nº 605/1949 trata do repouso semanal remunerado e do trabalho em feriados civis e religiosos, mas isso regula remuneração e folga, não é uma tabela de prazos de pagamento. No sistema bancário, o dia útil segue normas do Conselho Monetário Nacional e do Banco Central. Nenhuma dessas definições foi aberta integralmente como fonte para este guia, então o caminho seguro é: leia o que o contrato ou a norma diz e use a ferramenta para a aritmética, não para decidir qual definição vale.

## Vencimento em dia não útil

O Código Civil, art. 132, diz que, salvo disposição legal ou convencional em contrário, os prazos contam-se excluindo o dia do começo e incluindo o do vencimento. O § 1º acrescenta: se o dia do vencimento cair em feriado, o prazo fica prorrogado até o dia útil seguinte. Repare nas ressalvas: contrato e lei específica podem dizer outra coisa, e o texto fala de feriado. Para boleto, financiamento ou tributo, vale a regra do documento ou da norma do caso. Confirme na fonte, sem tomar este texto como orientação jurídica.

## Exemplos reais, calculados com a ferramenta

Os números abaixo saem do mesmo código da ferramenta Dias úteis (https://meajudaflow.com.br/tools/dias-uteis), com os feriados nacionais fixos ligados.

### Novembro de 2026

Em novembro de 2026 há três dias não úteis na semana de trabalho ou próximos: 2 de novembro (segunda, Finados), 15 de novembro (domingo, Proclamação da República) e 20 de novembro (sexta, Consciência Negra). O 15 cai no domingo, então não tira um dia útil extra.

- Entre 2 e 30 de novembro de 2026, com as duas pontas contando: 19 dias úteis. Sem considerar feriados, seriam 21.
- Prazo de 10 dias úteis a partir de 9 de novembro de 2026 (o dia de partida não conta): vence em 24/11/2026. Sem feriados, venceria em 23/11/2026. A sexta-feira 20 de novembro empurrou o vencimento um dia.

- Prazo de 20 dias úteis a partir de 2 de novembro de 2026: vence em 01/12/2026. Sem feriados, em 30/11/2026.

### Carnaval e Corpus Christi de 2026

- De 9 a 27 de fevereiro de 2026, com os feriados nacionais fixos, são 15 dias úteis. Tratando segunda e terça de Carnaval como dias parados, caem para 13.
- De 1 a 12 de junho de 2026: 10 dias úteis. Com Corpus Christi (4 de junho) tratado como parado, 9.

A diferença de um ou dois dias é justamente o que muda a data de vencimento. Por isso decida antes, e por escrito, se pontos facultativos contam como dia útil no seu prazo.

## Roteiro rápido

- Defina se a data de partida conta (a regra do Código Civil exclui o dia do começo).
- Escolha a lista de feriados: só os nacionais por lei, ou também Sexta-feira Santa, Carnaval e Corpus Christi.

- Acrescente à mão feriados estaduais e municipais que valham para o seu caso.
- Calcule, e guarde junto ao registro quais opções foram usadas.

- Em caso de dúvida sobre prazo com consequência financeira ou legal, confirme na fonte oficial ou com quem responde pelo contrato.

## Calcule no Me Ajuda Flow

Para somar ou contar dias úteis com feriados nacionais, opções de Sexta-feira Santa, Carnaval e Corpus Christi, e datas extras, use a ferramenta Dias úteis (https://meajudaflow.com.br/tools/dias-uteis). Para diferença entre datas em dias, meses e anos, veja Datas (https://meajudaflow.com.br/tools/datas), e para tempo decorrido desde um nascimento, a calculadora de idade (https://meajudaflow.com.br/tools/calculadora-de-idade).

Fontes oficiais:
- Lei nº 662/1949, feriados nacionais (Planalto): https://www.planalto.gov.br/ccivil_03/leis/l0662.htm
- Lei nº 10.607/2002, inclui 21 de abril e 2 de novembro (Planalto): https://www.planalto.gov.br/ccivil_03/leis/2002/l10607.htm
- Lei nº 6.802/1980, 12 de outubro (Planalto): https://www.planalto.gov.br/ccivil_03/leis/l6802.htm
- Lei nº 14.759/2023, 20 de novembro (Planalto): https://www.planalto.gov.br/ccivil_03/_ato2023-2026/2023/lei/l14759.htm
- Lei nº 9.093/1995, feriados civis e religiosos (Planalto): https://www.planalto.gov.br/ccivil_03/leis/l9093.htm
- Código Civil, art. 132, contagem de prazos (Planalto): https://www.planalto.gov.br/ccivil_03/leis/2002/l10406compilada.htm
- Calendário oficial de feriados nacionais e pontos facultativos em 2026 (MGI, gov.br): https://www.gov.br/gestao/pt-br/assuntos/noticias/2025/dezembro/confira-o-calendario-oficial-de-feriados-nacionais-e-pontos-facultativos-em-2026

## Como gerar um PIX QR Code estático com segurança

URL: https://meajudaflow.com.br/guias/gerar-pix-qr-code-estatico-com-seguranca
Atualizado em: 2026-11-02

O QR estático é só um texto com a sua chave, montado por você e sem registro no banco. Isso o torna simples e barato, mas deixa a conferência por sua conta. Veja os campos, os limites que importam, um teste de 1 centavo antes de divulgar e os riscos de trocar ou adulterar o código.

## O que é o QR estático

Um PIX QR Code estático é a imagem de um texto no padrão BR Code (o mesmo do "copia e cola") que carrega a sua chave Pix e, opcionalmente, valor, identificador e uma mensagem. Segundo o Manual de Padrões para Iniciação do Pix, ele pode ser criado diretamente por você ou por um software, e a criação do QR estático não faz parte da API Pix: o banco não registra o código, não o valida e não sabe que ele existe até alguém pagar. Por isso, quem gera é responsável por gerar certo e por conferir.

No QR dinâmico acontece o contrário. O código traz uma URL e o aplicativo do pagador consulta o banco do recebedor para obter valor, beneficiário e situação da cobrança. Valor e txid dentro de um QR dinâmico devem ser ignorados pelo pagador, pois valem os dados obtidos pela URL. Dinâmico serve para cobranças com valor e prazo controlados pelo banco ou pelo sistema de cobrança; estático serve para um código que você mesmo monta e reutiliza.

## Os campos do BR Code, um a um

Cada campo tem o formato ID (2 dígitos), tamanho (2 dígitos), valor. Para o QR estático, os que importam são:

- 00, versão: fixo em 01.
- 01, método de iniciação: o Manual do BR Code define que o valor 12 significa que o código só pode ser usado uma vez. O gerador do Me Ajuda Flow grava 11, o código reutilizável.

- 26, conta do recebedor: contém o subcampo 00 (br.gov.bcb.pix), o 01 (a chave, de 1 a 77 caracteres) e, opcionalmente, o 02 (mensagem ao pagador).
- 52 e 53: categoria do comércio (0000 quando não informada) e moeda (986, real).

- 54, valor: opcional, de 1 a 13 caracteres, com ponto decimal (exemplos do manual: 0, 1.00, 123.99).
- 58, 59 e 60: país (BR), nome do recebedor (1 a 25 caracteres) e cidade (1 a 15 caracteres).

- 62, subcampo 05, txid: de 1 a 25 caracteres. Se você não usar identificador, o valor deve ser ***.
- 63, CRC16: sempre o último, com 4 caracteres, calculado sobre todo o texto anterior incluindo o 6304.

Os subcampos do campo 26 (chave e mensagem) dividem um espaço de 99 caracteres. Quanto maior a chave, menos sobra para a mensagem. Com uma chave aleatória de 36 caracteres, o gerador do Me Ajuda Flow aceita no máximo 37 caracteres de mensagem; com 100 caracteres, ele recusa e informa o limite.

## Valor fixo ou livre

A decisão depende do uso do QR, e o Manual de Padrões para Iniciação do Pix trata os dois casos:

- Sem valor (livre). O pagador digita. Serve para um QR impresso e permanente, como doação, caixa de loja ou cartão de visita. Risco: o pagador pode digitar um valor errado e nada no código impede isso.
- Com valor fixo. O pagador vê o valor já preenchido. Serve para uma cobrança específica, como o pedido 42 de R$ 150,00. Risco: se o QR for reaproveitado, qualquer pessoa pode pagar o mesmo valor de novo,, pois o código em si não registra que já foi pago.

Regra prática: QR impresso e permanente, sem valor; QR de uma cobrança, com valor e com txid próprio. Se precisar de garantia de uso único ou de prazo de validade, o caminho é a cobrança dinâmica, não um estático com truques.

## Nome, cidade e txid

O nome (campo 59) e a cidade (campo 60) são exigidos pelo padrão, mas, conforme nota do Manual de Padrões para Iniciação do Pix, o nome apresentado ao pagador é o retornado pela consulta à chave no DICT, e o do QR é ignorado. Mesmo assim, respeite os limites de 25 e 15 caracteres, senão aplicativos e bibliotecas podem recusar o código.

Exemplo real, gerado com o código do Me Ajuda Flow: nome Padaria Pão Quente e Cia Ltda e cidade São Bernardo do Campo. O gerador tirou os acentos, passou para maiúsculas e cortou nos limites, e o resultado foi PADARIA PAO QUENTE E CIA (24 caracteres) e SAO BERNARDO DO (15 caracteres). Repare no corte da cidade: ela termina em "DO", pela contagem de caracteres. Como a cidade é mero dado do código, isso não impede o pagamento, mas, se preferir, abrevie você mesmo (por exemplo, S B DO CAMPO).

O txid aceita só letras maiúsculas, minúsculas e dígitos, até 25 caracteres. Um identificador como PED-0042 é recusado pelo gerador por causa do hífen; PED0042 passa. O manual explica por que o txid importa: ele é retransmitido pelo banco do pagador e permite ao recebedor casar o Pix recebido com a cobrança, e os Pix com txid podem ser consultados pela API Pix. O mesmo manual avisa que o banco do recebedor não tem como impedir que um txid se repita em QR estático. Repetir o txid é desejável em um QR fixo sem valor e deve ser evitado em um QR gerado para cada venda. Quem garante isso é você.

## Exemplo completo com valor e txid

Dados fictícios: chave financeiro@exemplo.com.br, valor 150,00 e txid PED0042. O gerador monta este código de 164 caracteres:

```
00020101021126470014br.gov.bcb.pix0125financeiro@exemplo.com.br5204000053039865406150.005802BR5924PADARIA PAO QUENTE E CIA6015SAO BERNARDO DO62110507PED004263047BEB
```

Lendo: o campo 5406150.00 é o valor, 5924 declara 24 caracteres de nome, 62110507PED0042 traz o txid e 63047BEB é o CRC16. Passando esse texto no decodificador, o resultado é estático, chave financeiro@exemplo.com.br, valor 150.00, txid PED0042 e nenhum aviso. Observe que o valor foi escrito com vírgula na entrada e saiu com ponto no código, que é o formato exigido.

Sem valor nem txid, com uma chave aleatória, o código fica mais curto (143 caracteres): ...5802BR5913FULANO DE TAL6008BRASILIA62070503***6304A5E2. O *** indica que não há identificador.

## Como conferir o código gerado

- Decodifique o texto. Cole o código na ferramenta de PIX copia e cola (https://meajudaflow.com.br/tools/pix). O CRC deve constar como conferido e não deve haver avisos.
- Releia a chave, caractere por caractere. É o dado que define para onde o dinheiro vai. Compare com a chave cadastrada no seu banco.

- Confira o tipo. O decodificador deve mostrar "estático". Se mostrar uma URL, o código é dinâmico.
- Leia o QR com o celular e confirme que o aplicativo mostra o nome correto do recebedor, que vem da consulta à chave, e não do código.

- Faça o teste de valor baixo, descrito abaixo.

## Teste com valor baixo antes de divulgar

O valor mínimo do campo 54 aceito pelo gerador é 0.01: digitando 0,01, sai 5404 mais 0.01 no código. Uma sequência segura:

- Gere o QR final, exatamente como será impresso ou enviado, com o mesmo valor, txid e nome.
- Para o teste, gere uma versão com 0,01 e pague de uma conta diferente da conta do recebedor.

- Veja no extrato do recebedor se o Pix caiu na conta certa e se o identificador aparece quando o seu banco o exibe.
- Só então publique ou imprima o QR definitivo. Se o definitivo tiver outro valor, repita a conferência no decodificador, pois a mudança de um caractere altera o CRC.

O teste de centavo não substitui a conferência: ele prova que a chave existe e recebe, não que o resto do código está como você quer.

## Riscos: troca de chave e QR adulterado

O CRC16 detecta erro de cópia, mas não protege contra fraude. Quem altera a chave e recalcula o CRC produz um código perfeitamente válido. Teste real: no código de R$ 150,00 acima, troquei a chave por financeiro@exemplo.com.bs sem recalcular o CRC e o decodificador acusou o erro (informado 7BEB, calculado 239C). Depois recalculei o CRC sobre o texto adulterado e o decodificador passou a aceitá-lo sem nenhum aviso, mostrando a chave falsa. Ou seja, o único sinal de adulteração é a própria chave, e ela só aparece se alguém olhar.

- QR impresso: o golpe clássico é colar outro QR por cima do seu, em balcão, cartaz ou etiqueta. Confira os pontos de afixação periodicamente, proteja o QR (por exemplo, impresso em material difícil de cobrir sem deixar marca) e oriente o pagador a conferir o nome do recebedor na tela de confirmação antes de pagar.
- Código enviado por mensagem: quem recebe o texto não tem como saber se foi editado no caminho. Envie o código por um canal confiável e, se possível, informe também o nome do recebedor para comparação.

- Sua chave, seu risco: se você trocar ou excluir a chave no banco, todo QR já impresso com ela deixa de funcionar. Atualize o material antes de mudar a chave.
- Geradores de terceiros: quem gera o código vê a sua chave e o valor. Use ferramentas que rodem no seu navegador ou sistemas que você controla, e decodifique o resultado antes de usar.

## Checklist de geração

- Chave conferida com o cadastro do banco.
- Valor com ponto e duas casas, ou em branco, de acordo com o uso.

- Nome até 25 e cidade até 15 caracteres, em maiúsculas e sem acento.
- txid só com letras e números, até 25 caracteres, ou ***.

- CRC conferido e sem avisos no decodificador.
- Teste de R$ 0,01 de outra conta, com verificação no extrato.

- Nome do recebedor conferido na tela do aplicativo ao ler o QR.

Os limites e formatos acima seguem os manuais do Banco Central listados nas fontes. Regras de cada banco, como limites por transação e horários, devem ser confirmadas com a sua instituição.

## Gere e confira com as ferramentas

Para montar o código e o QR já com os limites aplicados, use o gerador de PIX QR Code (https://meajudaflow.com.br/tools/pix-qr) do Me Ajuda Flow, e confira o resultado no decodificador de PIX (https://meajudaflow.com.br/tools/pix). Se for gerar para um CPF ou CNPJ como chave, valide o número antes na ferramenta de CPF e CNPJ (https://meajudaflow.com.br/tools/cpf-cnpj).

Fontes oficiais:
- Manual do BR Code (Banco Central do Brasil): https://www.bcb.gov.br/content/estabilidadefinanceira/ativosdosite/Manual%20do%20BR%20Code.pdf
- Manual de Padrões para Iniciação do Pix (Banco Central do Brasil): https://www.bcb.gov.br/content/estabilidadefinanceira/pix/Regulamento_Pix/II_ManualdePadroesparaIniciacaodoPix.pdf

## Tabela Price ou SAC: como escolher e calcular

URL: https://meajudaflow.com.br/guias/tabela-price-ou-sac-como-escolher-e-calcular
Atualizado em: 2026-11-02

Price e SAC usam a mesma taxa de juros, mas distribuem juros e amortização de formas diferentes. Isso muda o valor da primeira parcela, o ritmo em que a dívida cai e o total de juros. Veja a conta nos dois sistemas, com números calculados e o que o CET acrescenta.

## A ideia em uma frase

Em qualquer financiamento, cada parcela tem duas partes: os juros do mês, calculados sobre o saldo devedor, e a amortização, que é a parte que reduz a dívida. A diferença entre Price e SAC está só em como essas duas partes são combinadas. A taxa é a mesma.

## Como a Tabela Price calcula

Na Price, a parcela é constante. O valor é obtido por esta fórmula, com PV o valor financiado, i a taxa mensal e n o número de parcelas:

```
parcela = PV x i / (1 - (1 + i)^-n)
```

Como os juros do primeiro mês incidem sobre o saldo inteiro, eles ocupam boa parte da parcela, e sobra pouco para amortizar. A cada mês o saldo cai um pouco, os juros diminuem e a amortização cresce, sempre com a parcela igual.

## Como o SAC calcula

No SAC (Sistema de Amortização Constante), a amortização é fixa: PV dividido por n. Os juros de cada mês são calculados sobre o saldo que resta, então a parcela (amortização mais juros) começa mais alta e diminui todo mês, em uma queda regular.

```
amortização = PV / n
parcela do mês k = amortização + saldo devedor x i
```

## Exemplo 1: R$ 200.000, 1% ao mês, 12 meses

Resultados calculados com as funções do financiamento do Me Ajuda Flow, em reais:

| Parcela | Price (parcela) | SAC (parcela) | SAC (juros) | SAC (amortização) |
| --- | --- | --- | --- | --- |
| 1 | 17.769,76 | 18.666,66 | 2.000,00 | 16.666,66 |
| 2 | 17.769,76 | 18.499,99 | 1.833,33 | 16.666,66 |
| 3 | 17.769,76 | 18.333,33 | 1.666,67 | 16.666,66 |
| 12 | 17.769,72 | 16.833,41 | 166,67 | 16.666,74 |

Na Price, os juros do primeiro mês são R$ 2.000,00 e a amortização, R$ 15.769,76. No SAC, os mesmos R$ 2.000,00 de juros, mas R$ 16.666,66 amortizados. Total de juros: R$ 13.237,08 na Price e R$ 13.000,00 no SAC, uma diferença de R$ 237,08. As diferenças de centavos na última parcela vêm do arredondamento ao centavo.

## Exemplo 2: o mesmo valor em 240 meses (20 anos)

Com prazo longo, a diferença deixa de ser pequena:

- Price: parcela fixa de R$ 2.202,17. Total pago: R$ 528.523,57. Juros: R$ 328.523,57.
- SAC: primeira parcela de R$ 2.833,33 e última de R$ 842,47. Total pago: R$ 441.000,94. Juros: R$ 241.000,94.

- Diferença de juros: R$ 87.522,63 a mais na Price.

Na Price, a primeira parcela tem R$ 2.000,00 de juros e só R$ 202,17 de amortização. Depois de 12 parcelas, o saldo devedor é de R$ 197.435,99 na Price e R$ 190.000,04 no SAC. Depois de 60 parcelas, R$ 183.488,91 contra R$ 150.000,20. Ou seja, no SAC a dívida cai mais rápido desde o começo, e é por isso que os juros totais são menores.

## Qual tem parcela menor?

Depende do momento. No exemplo de 240 meses, a primeira parcela do SAC é R$ 630,00 maior que a da Price (R$ 2.833,33 contra R$ 2.202,17). A parcela do SAC cai abaixo do valor fixo da Price na parcela 77, quando chega a R$ 2.200,00. Antes disso o SAC pesa mais no orçamento; depois, menos.

- Price costuma servir a quem precisa de parcela inicial menor ou de previsibilidade, aceitando pagar mais juros no total.
- SAC costuma servir a quem tem folga para a parcela inicial maior e quer reduzir o custo total e o saldo devedor mais depressa.

Essa é uma regra para taxa e prazo iguais. A taxa que cada banco oferece para cada sistema pode ser diferente, e a conclusão pode mudar. Compare sempre as duas propostas completas.

## O que a conta de Price e SAC deixa de fora

Os exemplos acima usam apenas o saldo, a taxa e o prazo. Um contrato real pode ter, além das parcelas:

- tarifas cobradas na contratação;
- tributos, como o IOF, quando incidirem na operação;

- seguros vinculados ao contrato;
- outras despesas ligadas à operação.

Nada disso aparece na tabela de amortização. Por isso, comparar só a "taxa de juros" e a parcela pode enganar.

## CET: o número que reúne tudo

O Banco Central define o Custo Efetivo Total (CET) como uma taxa que representa, na data do cálculo, de forma consolidada, os encargos e as despesas da operação (art. 2 da Resolução CMN 4.881/2020). A norma diz que o cálculo considera o valor do crédito e os valores cobrados do interessado: amortizações, juros, tarifas, tributos, seguros e outras despesas vinculadas à operação, inclusive as de serviços de terceiros contratados pela instituição por conta do tomador (art. 3).

- É expresso como taxa percentual anual, divulgada com duas casas decimais (art. 4, parágrafo único).
- A instituição deve informar o CET antes da contratação e apresentar o demonstrativo de cálculo, com o valor em reais de cada componente (art. 7).

- O CET deve constar também nos informes publicitários que divulguem a taxa de juros (art. 8).
- A resolução vale para operações com pessoas naturais e com microempresas e empresas de pequeno porte, e não se aplica a crédito rural nem a repasses de recursos externos (arts. 1 e 9).

O CET usa como valor inicial o crédito concedido menos despesas e tarifas pagas antecipadamente. Por isso, uma tarifa cobrada no ato aumenta o CET mesmo sem mexer na taxa de juros.

### Exemplo numérico com a fórmula do art. 4

Aplicando a fórmula da resolução (fluxos descontados por dias corridos, base de 365 dias) ao financiamento de R$ 200.000 em 240 parcelas a 1% ao mês, com liberação em 15/01/2026 e parcelas todo dia 15, e uma tarifa hipotética de R$ 3.000,00 paga no ato:

- sem tarifa, o CET fica em 12,68% ao ano nos dois sistemas, igual a 1% ao mês convertido em taxa anual (1,01^12);
- com a tarifa, o CET sobe para cerca de 12,95% ao ano na Price e 13,01% no SAC.

É um cálculo ilustrativo, feito aqui com datas fixas. O CET oficial é o que consta do demonstrativo da instituição, com as datas e as condições reais do seu contrato. Note ainda que, quando há taxa que varia no tempo (como índices de preços), esses parâmetros não entram no CET e são informados à parte (art. 5).

O Boletim Consumo e Finanças do Banco Central e da Senacon traz a mesma recomendação prática: antes de contratar, compare o CET de ofertas com mesmo valor e prazo, e não apenas a taxa de juros.

## Roteiro para decidir

- Peça as duas simulações, Price e SAC, com o mesmo valor financiado e o mesmo prazo.
- Anote a primeira parcela, a última e o total pago em cada uma.

- Veja se a primeira parcela do SAC cabe no seu orçamento com folga.
- Compare o CET e o demonstrativo de cálculo de cada proposta, não só a taxa nominal.

- Confirme no contrato quais tarifas, tributos e seguros estão incluídos e se algum é opcional.

Este guia explica a matemática dos sistemas e o conceito de CET. Ele não substitui a leitura do contrato nem a orientação de um profissional.

Para simular o seu caso nos dois sistemas e ver a tabela mês a mês, use a ferramenta de financiamento (https://meajudaflow.com.br/tools/financiamento) do Me Ajuda Flow. Para entender a conversão entre taxa mensal e anual, veja juros compostos (https://meajudaflow.com.br/tools/juros-compostos), e para variações e acréscimos percentuais, porcentagem (https://meajudaflow.com.br/tools/porcentagem).

Fontes oficiais:
- Resolução CMN nº 4.881/2020: cálculo e informação do Custo Efetivo Total (Banco Central do Brasil): https://www.bcb.gov.br/content/estabilidadefinanceira/especialnor/Resolu%C3%A7%C3%A3o4881.pdf
- Boletim Consumo e Finanças nº 8: CET, Custo Efetivo Total (Banco Central do Brasil e Senacon): https://www.gov.br/mj/pt-br/assuntos/seus-direitos/consumidor/Anexos/boletimconsumofinancas08-cet-2013-custo-efetivo-total.pdf

## Golpes de PIX e boleto: o que conferir antes de pagar

URL: https://meajudaflow.com.br/guias/golpes-de-pix-e-boleto-o-que-conferir-antes-de-pagar
Atualizado em: 2026-11-02

Um código que passa em todas as verificações técnicas ainda pode levar o dinheiro para a conta errada. Veja o que checar antes de confirmar um PIX ou um boleto, o que um decodificador consegue provar, o que ele não consegue e quais são os caminhos oficiais se o golpe já aconteceu.

## A regra de ouro: confira quem recebe, não só o valor

A maior parte das fraudes com PIX e boleto não quebra nenhuma regra técnica. O golpista troca o destino por um código novo, válido e bem formado. Por isso a verificação que protege é a humana: o nome e o documento de quem vai receber, mostrados pelo seu banco na tela de confirmação, precisam bater com a empresa ou a pessoa com quem você negociou.

O Procon-SP descreve justamente esse padrão: em lojas virtuais, criminosos substituem o QR Code (e também o texto do copia e cola) por um que desvia o dinheiro, e a orientação é não conferir só o valor, mas verificar no aplicativo o nome e o CNPJ do destinatário antes de autorizar. Se não baterem, não conclua o pagamento.

## PIX: o que conferir

- Nome e documento na tela de confirmação do seu banco. Pelo Manual de Padrões para Iniciação do Pix, o nome apresentado ao pagador é o nome retornado pela consulta ao DICT (o diretório de chaves), e o nome gravado dentro do código (campo 59) é ignorado pelo aplicativo. Ou seja, o nome que aparece no decodificador é só o que quem gerou o código escreveu. O nome do seu banco é o que vale.
- Valor. Em PIX estático o valor está dentro do código e pode ter sido alterado. Em PIX dinâmico ele vem da cobrança no banco do recebedor.

- Origem do código. Pediu a cobrança por um canal que você conhece? Código recebido por mensagem de um número novo, ou mudança de chave "de última hora", merece confirmação por outro canal.
- Tipo. Estático (a chave está no texto) ou dinâmico (o texto traz uma URL da cobrança).

### Exemplos reais com o decodificador

Todos usam dados fictícios. O código original, com chave financeiro@exemplo.com.br, valor 123.45 e CRC 882B:

```
00020101021126470014br.gov.bcb.pix0125financeiro@exemplo.com.br5204000053039865406123.455802BR5918EMPRESA TESTE LTDA6009SAO PAULO62070503***6304882B
```

- Chave trocada à mão (exemplo virou exemp1o, com o número 1): o decodificador respondeu CRC informado 882B, calculado 6D9A. Edição simples é pega pelo CRC.
- Valor alterado de 123.45 para 923.45 sem recalcular: informado 882B, calculado 66A8. Também é pego.

- Código forjado do zero: gerei outro código com a chave pagamentos@outra-conta.com.br, mesmo nome, mesma cidade e mesmo valor, com CRC recalculado (C9E9). Resultado: CRC confere e nenhum aviso. O decodificador mostra a chave, mas não tem como saber que ela pertence a outra pessoa.

A lição do terceiro caso é o ponto central deste guia: o CRC prova que o texto não foi alterado depois de gerado, não que foi gerado por quem deveria. Qualquer pessoa consegue calcular um CRC válido.

## Boleto: o que conferir

- Banco na linha digitável. Os três primeiros dígitos são o código da instituição destinatária, a mesma impressa em destaque no canto superior esquerdo da ficha de compensação, segundo o Anexo V da convenção da FEBRABAN. Se o boleto veio de um prestador que sempre cobra por um banco e agora aparece outro, pergunte.
- Dígitos verificadores. A linha de 47 dígitos tem três DVs por módulo 10 e um DV geral por módulo 11. Eles pegam erro de digitação e alteração descuidada.

- Valor e vencimento do código contra o que está impresso e contra o que combinou.
- Beneficiário. Compare o nome e o CNPJ do beneficiário com o de quem emitiu a cobrança. Se o seu aplicativo mostrar o beneficiário antes da confirmação, essa é a checagem mais forte; o que seu banco exibe deve ser confirmado no próprio app.

### Exemplos reais com o decodificador

Linha de teste (o campo livre, que é específico de cada banco, é inventado aqui):

```
34191234546789012345767890123457316360000012345
```

O decodificador de boleto leu: banco 341 (Itaú Unibanco), valor R$ 123,45, vencimento 2026-11-20 (fator 1636, ciclo iniciado em 22/02/2025), todos os dígitos verificadores corretos. Variações:

- Um dígito do valor alterado na linha (o valor virou 90000123.45): alerta de "DV geral não confere (informado 3, esperado 1)". Alteração sem recálculo é pega.
- Valor alterado com DVs recalculados (R$ 9.123,45): nenhum alerta. Um boleto regenerado com valor maior é "válido" para qualquer verificador.

- Banco diferente: a mesma estrutura com código 260 passou sem alerta e foi identificada como Nubank. Os dígitos verificadores não sabem qual banco era o esperado, só você sabe.

Duas ressalvas. O decodificador do Me Ajuda Flow tem uma lista curta de bancos: se o nome vier vazio, isso não indica fraude, só que o código não está na lista. E o vencimento pode ser ambíguo: desde 22/02/2025 o fator reinicia em 1000, então o mesmo número cabe em dois ciclos, e a ferramenta mostra a data mais próxima de hoje. No exemplo acima, a outra data possível é 2002-03-31.

## O que o decodificador prova e o que não prova

| Prova | Não prova |
| --- | --- |
| O PIX segue o formato BR Code e o CRC bate | Que a chave pertence a quem você pensa |
| Os DVs do boleto estão coerentes | Que o boleto foi emitido pelo beneficiário esperado |
| Valor, banco e fator de vencimento do código | Que o valor e o vencimento são os combinados |
| Que o PIX é estático ou dinâmico | Que a cobrança dinâmica está ativa: ele não consulta a URL |

Na convenção da FEBRABAN, nas relações entre bancos o registro do boleto na Base Centralizada da Cobrança prevalece sobre o que está impresso. Isso protege a operação entre instituições, mas não verifica se o beneficiário registrado é quem você queria pagar. Essa conferência continua com você.

## Se você já pagou: caminhos oficiais

O Banco Central mantém o Mecanismo Especial de Devolução (MED) para PIX. O que consta no Guia do MED, e o que você deve confirmar com o seu banco:

- Como pedir. O pagador abre uma contestação pelo aplicativo do seu banco (a funcionalidade de autoatendimento do MED) ou pelo canal de atendimento, relatando o golpe. O guia prevê que isso vale mesmo se você autorizou com senha ou biometria.
- Prazo. A transação original deve ter no máximo 80 dias na abertura do pedido. Aja logo. O guia também prevê que o banco do recebedor possa fazer um bloqueio cautelar de valores por até 72 horas quando houver suspeita de fraude.

- Não há garantia. A devolução depende de se confirmar a fraude e do saldo disponível na conta do recebedor: o guia prevê devolução parcial, ou nenhuma, se o dinheiro já saiu da conta.
- O que fica de fora. O MED não é chargeback. O guia exclui, por exemplo, PIX enviado para o destinatário errado por engano do pagador, desacordo comercial e dinheiro que o golpista usou para comprar de um terceiro de boa-fé.

- Se o banco não resolver. Pelos Requisitos Mínimos para a Experiência do Usuário, o aplicativo deve informar que você pode registrar reclamação no site do Banco Central.

Guarde prints, protocolos e o comprovante. O Procon-SP recomenda também avisar a loja, quando for o caso. Há versões do Guia do MED com vigências diferentes ao longo de 2026, então confira o texto atual no site do Banco Central. Para boleto, não encontrei na fonte um mecanismo equivalente ao MED, então o caminho é o contato imediato com seu banco e com o banco do beneficiário. Este guia é informativo e não substitui orientação jurídica.

## Checklist de 30 segundos

- O nome e o documento mostrados pelo seu banco são os do fornecedor?
- O valor e o vencimento são os combinados?

- O banco do boleto é o esperado? Chave de PIX nova ou conta diferente do habitual?
- O código chegou por um canal confiável, e foi confirmado por outro?

- O decodificador mostra CRC e DVs corretos? Ótimo, mas isso é só a parte técnica.

Cole o código na ferramenta PIX copia e cola (https://meajudaflow.com.br/tools/pix) para ver chave, nome, valor e CRC campo a campo, e a linha digitável em boleto (https://meajudaflow.com.br/tools/boleto) para ver banco, valor e vencimento. Se o pagamento é de uma compra com nota, confira a chave de acesso em chave de NF-e (https://meajudaflow.com.br/tools/nfe).

Fontes oficiais:
- Manual de Padrões para Iniciação do Pix (Banco Central do Brasil): https://www.bcb.gov.br/content/estabilidadefinanceira/pix/Regulamento_Pix/II_ManualdePadroesparaIniciacaodoPix.pdf
- Guia de implementação dos procedimentos de devolução no Pix, com ênfase no MED (Banco Central do Brasil): https://www.bcb.gov.br/content/estabilidadefinanceira/pix/Guia_MED.pdf
- Convenção entre Instituições do Sistema Financeiro, boleto de pagamento (FEBRABAN): https://cmsarquivos.febraban.org.br/Arquivos/documentos/PDF/Conven%C3%A7%C3%A3o%20da%20Cobran%C3%A7a%20-%2005_02_2021_f.pdf
- Requisitos Mínimos para a Experiência do Usuário do Pix (Banco Central do Brasil): https://bcb.gov.br/content/estabilidadefinanceira/pix/Regulamento_Pix/IV_RequisitosMinimosparaExperienciadoUsuario.pdf
- Procon-SP orienta sobre golpe que altera o QR Code do Pix em compras online: https://www.procon.sp.gov.br/procon-sp-orienta-consumidores-sobre-novo-golpe-que-altera-qr-code-do-pix-em-compras-online/

## Erros comuns de JSON e como corrigir cada um

URL: https://meajudaflow.com.br/guias/json-erros-comuns-e-como-corrigir
Atualizado em: 2026-11-02

Quase todo JSON recusado cai em um punhado de erros de sintaxe. Veja cada um com o exemplo inválido, a mensagem que o parser mostra e a correção, e como achar o ponto exato no seu texto.

## Por que o JSON é tão rígido

JSON é um formato de sintaxe pequena e fechada, definido na RFC 8259 e no padrão ECMA-404. Ele não aceita comentários, vírgula no fim, aspas simples nem valores como NaN. Muita gente chega ao JSON vindo de código JavaScript, de arquivos de configuração ou de uma planilha, e leva hábitos que lá funcionam. Aqui o parser para no primeiro problema e devolve uma mensagem curta, que muda de um navegador ou ferramenta para outro.

Os exemplos abaixo foram executados de verdade em dois lugares: o verificador de JSON do Me Ajuda Flow (que informa linha e coluna) e o JSON.parse do Node.js 24, que usa o mesmo motor V8 do Chrome. Outros navegadores, como Firefox e Safari, escrevem mensagens diferentes para o mesmo erro, então use o texto como pista e a posição como guia.

## 1. Vírgula sobrando no fim

É o erro número um, e acontece quando você apaga o último item de uma lista e deixa a vírgula do anterior.

```
{"a":1,"b":2,}
```

- Verificador do site: "Vírgula sobrando antes de }" (linha 1, coluna 14).
- Node.js 24: Expected double-quoted property name in JSON at position 13 (line 1 column 14).

Em listas a mensagem do Node.js é diferente: para [1,2,3,] ele diz Unexpected token ']', e o site diz "Vírgula sobrando antes de ]" na coluna 8. A gramática da RFC 8259 só permite vírgula entre itens, nunca depois do último. Conserto: apague a vírgula final: {"a":1,"b":2}.

## 2. Faltou vírgula entre itens

O inverso do anterior. Muito comum ao colar um item novo no meio de um objeto.

```
{"a":1 "b":2}
```

O site responde "Esperava ',' ou '}' (faltou uma vírgula?)" na coluna 8, e o Node.js responde Expected ',' or '}' after property value in JSON at position 7. O ponto apontado é logo depois do valor que ficou sem vírgula. Conserto: {"a":1,"b":2}.

## 3. Aspas simples

Em JSON, texto e nomes de chave usam aspas duplas (o caractere U+0022 na gramática da RFC). Aspas simples são válidas em JavaScript e Python, mas não em JSON.

```
{'nome':'Ana'}
```

- Site: "Aspas simples não são permitidas; use aspas duplas" (linha 1, coluna 2).
- Node.js 24: Expected property name or '}' in JSON at position 1.

Conserto: {"nome":"Ana"}. Se o JSON saiu de um print de dicionário em Python, ele também traz True, False e None, que precisam virar true, false e null (a RFC exige as palavras em minúsculas). Teste real: {"ok":True} dá "Valor inesperado "True" (faltaram aspas em um texto?)" no site e Unexpected token 'T' no Node.js.

## 4. Nome de chave sem aspas

Em um literal de objeto JavaScript, {nome: "Ana"} é normal. Em JSON, toda chave é um texto e precisa de aspas duplas.

```
{nome:"Ana"}
```

O site diz "Esperava o nome de uma chave entre aspas duplas" (coluna 2) e o Node.js, a mesma mensagem do caso das aspas simples: Expected property name or '}'. A mensagem não distingue os dois casos, então olhe o caractere na posição indicada. Conserto: {"nome":"Ana"}.

## 5. Comentários

Nem a RFC 8259 nem o ECMA-404 definem comentários. A RFC admite que um parser pode aceitar extensões fora do padrão, mas você não pode contar com isso. Arquivos de configuração que aceitam comentários (o chamado JSONC, usado por algumas ferramentas) são outro formato.

```
{
  // total
  "a": 1
}
```

O site diz "Comentários não fazem parte do JSON" (linha 2, coluna 3) e o Node.js, Expected property name or '}' na mesma posição. Se o comentário vem depois de um valor, como em {"a":1 // x, a mensagem vira "Esperava ',' ou '}'", porque o parser não chega a reconhecer a barra como comentário. Conserto: apague o comentário. Se você precisa de uma anotação, guarde-a em um campo normal, por exemplo "observacao": "total".

## 6. Número com zero à esquerda, ponto solto ou sinal de mais

A gramática de números da RFC 8259 (seção 6) diz que zeros à esquerda não são permitidos. CEP, código de produto e telefone costumam cair aqui, porque parecem números mas são identificadores.

```
{"cep":01310}
```

O site responde "Número inválido (zero à esquerda, ponto sem dígitos ou texto colado ao número)" (coluna 8) e o Node.js, Unexpected number in JSON at position 8. Outros números inválidos pela mesma gramática, testados da mesma forma:

- {"v":5.} (ponto sem dígitos depois): o Node.js diz Unterminated fractional number.
- {"v":+5} (sinal de mais): Unexpected token '+'.

- {"v":0x1F} (hexadecimal): o parser lê o 0 e reclama do x.

Conserto: se é um identificador, coloque entre aspas: {"cep":"01310"}. Isso preserva o zero. Se é uma quantidade, escreva sem o zero extra (1310), sem + e com dígitos nos dois lados do ponto. Lembre também que o separador decimal é o ponto, nunca a vírgula.

## 7. Quebra de linha ou tabulação dentro de um texto

A RFC 8259 (seção 7) exige que os caracteres de controle, de U+0000 a U+001F, sejam escapados dentro de textos. Isso inclui a quebra de linha e a tabulação. Um valor digitado em duas linhas, ou colado de uma célula do Excel com Alt+Enter, quebra o JSON.

```
{"t":"linha1
linha2"}
```

- Site: "Quebra de linha ou caractere de controle dentro de uma string (use \n)" (linha 1, coluna 13).
- Node.js 24: Bad control character in string literal in JSON at position 12. O mesmo vale para uma tabulação real dentro do texto.

Conserto: troque a quebra real pela sequência \n (barra invertida e a letra n): {"t":"linha1\nlinha2"}. Quem gera o JSON por concatenação de texto deve usar uma função de serialização (como JSON.stringify), que escapa tudo sozinha. Atenção com a barra invertida em caminhos: "C:\\temp" é válido, mas escrito com uma barra só, \t é lido como tabulação.

## 8. BOM no início do arquivo

O BOM (U+FEFF) é um marcador invisível que alguns editores gravam no começo de arquivos UTF-8. A RFC 8259 (seção 8.1) diz que implementações não devem adicioná-lo a um JSON enviado por rede, e que o parser pode ignorá-lo em vez de tratá-lo como erro. Ou seja, o comportamento varia.

```
U+FEFF{"a":1}
```

Teste real: o verificador do Me Ajuda Flow ignora o BOM e aceita o texto. O JSON.parse do Node.js 24 recusa: Unexpected token '', "{"a":1}" is not valid JSON, com o caractere invisível aparecendo entre aspas. Esse é o caso mais confuso, porque o JSON parece perfeito. Conserto: salve o arquivo como "UTF-8" sem BOM, ou remova o primeiro caractere se ele for U+FEFF antes de analisar.

## 9. NaN, Infinity e undefined

A RFC 8259 (seção 6) diz que valores numéricos que a gramática não representa, como Infinity e NaN, não são permitidos. As únicas palavras-valor são true, false e null, em minúsculas. O undefined do JavaScript também não existe.

```
{"v":NaN}
```

O site diz "NaN e Infinity não existem em JSON" e, para {"v":undefined}, "undefined não existe em JSON; use null". O Node.js responde Unexpected token 'N' e Unexpected token 'u'. Um detalhe útil de verificar: JSON.stringify({a:NaN,b:undefined,c:Infinity}) devolve {"a":null,"c":null}. Ou seja, o NaN e o Infinity viram null e o campo undefined simplesmente some. Por isso o erro costuma aparecer quando o texto foi montado à mão, e não por JSON.stringify. Conserto: use null para "sem valor" e trate o cálculo que gerou o NaN antes de serializar.

## 10. Conteúdo depois do fim, texto cortado e chaves repetidas

- Dois JSONs colados: {"a":1}{"b":2} dá "Há conteúdo depois do fim do JSON" (coluna 8). Um texto JSON é um único valor. Para vários registros, envolva em uma lista: [{"a":1},{"b":2}].
- Texto cortado: {"a":[1,2 dá "O texto termina antes de fechar [" no site. O sinal é o parser chegar ao fim sem fechar colchetes ou chaves, comum em respostas truncadas ou copiadas pela metade.

- Chave repetida: {"a":1,"a":2} não é recusado nem pelo site nem pelo JSON.parse. A RFC 8259 (seção 4) diz que os nomes devem ser únicos e que, se repetidos, o comportamento de quem recebe é imprevisível. O site mantém os dois e avisa, mas a maioria dos sistemas fica só com o último valor. Remova a duplicata.

## Como achar o erro rápido

- Cole o texto inteiro no validador de JSON (https://meajudaflow.com.br/tools/json) e leia linha e coluna. O erro real costuma estar nesse ponto ou logo antes dele.
- Comece pelas causas mais frequentes: vírgula sobrando, vírgula faltando, aspas simples.

- Se o texto parece perfeito e mesmo assim falha, suspeite de caractere invisível (BOM, aspas "inteligentes" coladas de um editor de texto, espaço sem quebra).
- Depois de corrigir, formate o resultado e confira se os números e textos continuam como você queria, especialmente CEPs e códigos com zero à esquerda.

## Exemplo completo de correção

Este texto tem quatro problemas ao mesmo tempo: aspas simples, chave sem aspas, zero à esquerda e vírgula sobrando.

```
{'cliente':"Ana", ativo:true, "cep":01310, "tags":["a","b",],}
```

Corrigido, ele fica assim, e o validador do site o aceita sem erro:

```
{"cliente":"Ana","ativo":true,"cep":"01310","tags":["a","b"]}
```

Parsers mostram um erro por vez, então um texto assim exige várias tentativas. Corrija, valide de novo e repita até passar.

## Padrão de referência

Para decidir o que é ou não JSON válido, as referências são a RFC 8259 e o ECMA-404. O ECMA-404 define apenas a sintaxe, sem dizer como mapear valores para uma linguagem de programação. Se uma ferramenta aceita mais do que isso (comentários, vírgula final), ela está usando uma extensão, e o arquivo pode ser recusado por outro sistema.

Para validar, formatar e achar o ponto do erro, use a ferramenta JSON (https://meajudaflow.com.br/tools/json) do Me Ajuda Flow. Se o seu JSON vem de uma planilha, veja a conversão em CSV para JSON (https://meajudaflow.com.br/tools/csv-json), e para trocar entre formatos de configuração, JSON e YAML (https://meajudaflow.com.br/tools/json-yaml).

Fontes oficiais:
- RFC 8259: The JSON Data Interchange Format: https://www.rfc-editor.org/rfc/rfc8259
- ECMA-404: The JSON data interchange syntax (2ª edição): https://ecma-international.org/publications-and-standards/standards/ecma-404/

## Cron explicado: os 5 campos, exemplos e armadilhas comuns

URL: https://meajudaflow.com.br/guias/cron-explicado-com-exemplos-e-armadilhas
Atualizado em: 2026-11-02

Uma expressão cron parece código cifrado, mas segue uma regra curta: cinco campos, cada um com poucas opções. Veja como ler, como montar os casos do dia a dia e onde as pessoas mais erram.

## Os 5 campos

O cron padrão, descrito na página crontab(5), tem cinco campos separados por espaço, sempre nesta ordem:

```
minuto  hora  dia-do-mês  mês  dia-da-semana
0-59    0-23  1-31        1-12 0-7
```

No dia da semana, tanto 0 quanto 7 significam domingo. Nos campos de mês e dia da semana também valem os nomes com três letras (jan, mon), sem diferenciar maiúsculas de minúsculas. Os outros campos aceitam só números.

Lido da esquerda para a direita, 0 8 * * 1-5 significa: minuto 0, hora 8, qualquer dia do mês, qualquer mês, de segunda (1) a sexta (5). Ou seja, às 08:00 nos dias úteis.

## Os quatro operadores

- Asterisco (*): qualquer valor do campo.
- Lista (,): vários valores. 1,15 no dia do mês é dia 1 e dia 15.

- Intervalo (-): inclusivo nas duas pontas. 8-11 na hora é 8, 9, 10 e 11. O primeiro número não pode ser maior que o segundo.
- Passo (/): pula valores depois de um intervalo ou de um asterisco. */15 no minuto é 0, 15, 30 e 45. 0-23/2 na hora é uma hora sim, outra não.

Detalhe que pega muita gente: o passo vale só dentro do próprio campo. Segundo o manual, */23 no campo da hora roda nas horas 0 e 23, e não "a cada 23 horas corridas". Do mesmo modo, 0 */7 * * * não é "a cada 7 horas". Rodando no verificador do Me Ajuda Flow, a partir de sexta, 06/11/2026, às 12:00, os próximos horários são 14:00 e 21:00 de sexta, e depois 00:00, 07:00 e 14:00 de sábado: o intervalo entre 21:00 e 00:00 é de 3 horas, porque o contador reinicia a cada dia.

## A regra do OU entre dia do mês e dia da semana

Esta é a armadilha mais famosa. Quando os dois campos de dia estão restritos (nenhum deles começa com *), o cron não exige os dois: ele roda quando um ou o outro bater. O exemplo do próprio manual é 30 4 1,15 * 5, que roda às 04:30 nos dias 1 e 15 de cada mês e também em todas as sextas.

Na ferramenta, partindo de 06/11/2026, essa expressão devolveu: sex 13/11, dom 15/11, sex 20/11, sex 27/11 e ter 01/12, sempre às 04:30. Repare no dia 15, que caiu num domingo, e nas sextas que não são dia 1 nem 15. Quem queria "a sexta que cair no dia 1 ou 15" não terá o que esperava. Para o mesmo horário só nos dias 1 e 15, o dia da semana deve ficar com *: 30 4 1,15 * * devolveu 15/11, 01/12, 15/12, 01/01 e 15/01.

Se você precisa mesmo do E (por exemplo, "só quando o dia 1 for segunda"), o cron puro não resolve. A saída é agendar de forma mais ampla e checar a condição dentro do fluxo ou do script.

## Exemplos úteis, com próximos horários reais

Todos os horários abaixo foram calculados pela ferramenta de cron (https://meajudaflow.com.br/tools/cron), a partir de sexta, 06/11/2026, 12:00, no horário de Brasília.

### Todo dia útil às 08:00: 0 8 * * 1-5

Próximas execuções: seg 09/11, ter 10/11, qua 11/11, qui 12/11 e sex 13/11, todas às 08:00. Observe que "dia útil" aqui significa apenas segunda a sexta: feriados não são conhecidos pelo cron. Para pular feriados, o fluxo precisa conferir uma lista, como na ferramenta de dias úteis (https://meajudaflow.com.br/tools/dias-uteis), que considera feriados nacionais.

### A cada 15 minutos: */15 * * * *

Próximas: 12:15, 12:30, 12:45, 13:00 e 13:15. No GitHub Actions, a documentação informa que o intervalo mínimo de um agendamento é de 5 minutos e que execuções podem atrasar em horários de alta carga, principalmente no início de cada hora. Por isso, evite marcar tudo em 0.

### Segundas e quartas às 09:00: 0 9 * * 1,3

Próximas: seg 09/11, qua 11/11, seg 16/11, qua 18/11 e seg 23/11.

### Dia 31: 0 0 31 * *

O cron não corrige meses curtos: a expressão só roda em meses com dia 31. Partindo da mesma data, os próximos são 31/12/2026, 31/01/2027, 31/03/2027, 31/05/2027 e 31/07/2027. Fevereiro, abril, junho, setembro e novembro ficam de fora, e é aqui que muita gente perde uma rotina de fechamento.

## Último dia do mês quando o cron não suporta

O cron de 5 campos não tem "último dia". Uma alternativa comum é agendar nos dias 28 a 31 (0 9 28-31 * *) e deixar o fluxo decidir se hoje é mesmo o último. Com essa expressão, novembro de 2026 devolve 28/11, 29/11 e 30/11 às 09:00, e depois 28/12 e 29/12. Só uma dessas execuções por mês deve seguir adiante. Em Power Automate, a condição pode ser:

```
equals(dayOfMonth(addDays(utcNow(), 1)), 1)
```

Ela é verdadeira quando amanhã é dia 1. Atenção ao fuso: perto da meia-noite, o "amanhã" em UTC pode não coincidir com o seu. Se o fluxo roda de manhã, a diferença normalmente não aparece, mas vale testar com a data real.

Esta expressão foi validada pelo verificador do site, mas não afirmo aqui uma execução em um fluxo real: teste no seu ambiente antes de confiar.

Em outros agendadores existe suporte direto. A documentação do Azure Logic Apps mostra, para o gatilho Recurrence com frequência mensal, o valor "monthDays": [-1] no código do fluxo, para rodar uma vez no último dia do mês. A página é do Logic Apps; para o Power Automate, confirme na visualização de código do seu fluxo se o gatilho aceita esse formato antes de depender dele.

## Quartz: 6 ou 7 campos e o ponto de interrogação

O Quartz, muito usado em Java e em ferramentas baseadas nele, usa um formato diferente. Segundo a documentação, a expressão tem 6 ou 7 campos: segundos, minutos, horas, dia do mês, mês, dia da semana e, opcionalmente, ano. Além disso, existem símbolos que o cron padrão não entende:

- ? significa "sem valor específico" e deve ser usado em um dos dois campos de dia. A documentação diz que o suporte a ter os dois preenchidos é incompleto: é preciso usar ? em um deles.
- L é o último dia do mês (ou o último da semana, conforme o campo). L-3 conta três dias para trás.

- W escolhe o dia útil mais próximo de uma data, sem atravessar o mês.
- # escolhe a enésima ocorrência de um dia da semana: 6#3 é a terceira sexta, segundo a documentação.

Ou seja, o "todo dia útil às 08:00" no Quartz seria algo como 0 0 8 ? * MON-FRI; confira os nomes e a numeração dos dias na documentação do Quartz. Se você colar essa forma no verificador de cron de 5 campos do Me Ajuda Flow, ele recusa e avisa que ? é sintaxe do Quartz. O sinal é útil: um cron com 6 campos ou com ?, L, W ou # não é cron padrão. Também o contrário vale: o L não existe no manual do crontab.

## Fuso horário e horário de verão

O cron não carrega fuso: ele roda no fuso do serviço que o executa. No GitHub Actions, a documentação diz que os agendamentos rodam em UTC por padrão, com a opção de informar um fuso IANA pela chave timezone. Um 0 8 * * 1-5 escrito esperando 08:00 de Brasília seria executado às 08:00 UTC, que é 05:00 em Brasília (UTC-3).

Em fusos com horário de verão, o manual do crontab avisa que horários "pulados" nunca batem, e os jobs marcados nessa janela deixam de rodar; horários repetidos podem rodar duas vezes. O GitHub informa um comportamento diferente: horários em hora pulada passam para o próximo horário válido. Cada agendador decide, então confira o do seu.

No Power Automate, o gatilho Recurrence não usa cron: você escolhe frequência, intervalo, Time zone e, para frequência de dia ou semana, as horas e os minutos. O Microsoft Learn mostra o formato do início como AAAA-MM-DDTHH:MM:SSZ, com a letra Z indicando UTC. A documentação do Logic Apps recomenda selecionar um fuso horário para que o gatilho respeite o horário de verão; sem fuso, o horário pode deslocar uma hora quando o horário de verão começa ou termina. Para conferir a diferença entre dois fusos em uma data, use a ferramenta de fuso horário (https://meajudaflow.com.br/tools/fuso-horario).

O "todo dia útil às 08:00" no Recurrence fica assim: frequência Week, dias de segunda a sexta, hora 8, minuto 0 e o fuso correto. Segundo a documentação do Logic Apps, se você não informar os minutos, eles são calculados a partir de quando a recorrência começa, então preencha o campo de minutos.

## Checklist antes de publicar um agendamento

- Conte os campos: 5 é cron padrão; 6 ou 7 é Quartz.
- Se usar dia do mês e dia da semana ao mesmo tempo, lembre-se do OU.

- Confirme o fuso em que o serviço interpreta o horário.
- Rode a expressão na ferramenta de cron (https://meajudaflow.com.br/tools/cron) e confira os próximos cinco horários com os olhos, não só a sintaxe.

- Se a regra pedir "último dia", "dia útil de verdade" ou "terceira sexta", planeje a verificação dentro do fluxo.

Para montar e testar sua expressão, use a ferramenta de cron (https://meajudaflow.com.br/tools/cron) do Me Ajuda Flow: ela explica cada campo em português e mostra os próximos horários de execução.

Fontes oficiais:
- crontab(5), manual do Linux (man7.org): https://man7.org/linux/man-pages/man5/crontab.5.html
- CronTrigger Tutorial (Quartz Scheduler): https://www.quartz-scheduler.org/documentation/quartz-2.3.0/tutorials/crontrigger.html
- Eventos que disparam workflows: schedule (GitHub Docs): https://docs.github.com/en/actions/writing-workflows/choosing-when-your-workflow-runs/events-that-trigger-workflows
- Executar um fluxo de nuvem em um agendamento (Microsoft Learn): https://learn.microsoft.com/power-automate/run-scheduled-tasks
- Gatilho Recurrence no Azure Logic Apps (Microsoft Learn): https://learn.microsoft.com/azure/connectors/connectors-native-recurrence

## Fuso horário no Power Automate: utcNow, convertTimeZone e nomes do Windows

URL: https://meajudaflow.com.br/guias/fuso-horario-no-power-automate-converttimezone
Atualizado em: 2026-11-02

O fluxo gravou 11:30 e a pessoa tinha pedido 08:30? Quase sempre é o fuso: o Power Automate trabalha em UTC e a conversão para Brasília precisa ser feita por você, com o nome de fuso certo. Veja como fazer e onde as pessoas erram.

## O ponto de partida: utcNow() é UTC

A função utcNow() devolve o momento atual em UTC, com o Z no final. A documentação da Microsoft mostra o formato padrão assim: 2025-09-25T05:18:31.3384797Z. Não existe "hora local" automática: se o seu fluxo roda para uma equipe em Brasília, quem escreve a conversão é você.

No teste que fiz no Power Automate (fluxo de teste, sem conectores, em 02/11/2026), formatDateTime sobre uma data UTC, sem informar formato, devolveu 2026-11-02T08:05:09.0000000Z. O Z continua lá. Ou seja: se você grava esse valor direto em um e-mail ou em uma coluna de texto, a pessoa lê um horário UTC, que em Brasília está 3 horas adiantado.

## convertTimeZone: o jeito mais usado

Pela documentação, a sintaxe é convertTimeZone('<data>', '<fusoOrigem>', '<fusoDestino>', '<formato>'?). O formato é opcional. Para converter o agora de UTC para Brasília e já deixar legível:

```
convertTimeZone(utcNow(), 'UTC', 'E. South America Standard Time', 'dd/MM/yyyy HH:mm')
```

Executado no Power Automate com uma data fixa, para o resultado ser reproduzível:

```
convertTimeZone('2026-11-02T11:30:00Z', 'UTC', 'E. South America Standard Time', 'dd/MM/yyyy HH:mm')
resultado: 02/11/2026 08:30
```

Sem o parâmetro de formato, o resultado vem no padrão ISO, mas sem o Z. Executado:

```
convertTimeZone('2026-07-15T12:00:00Z', 'UTC', 'E. South America Standard Time')
resultado: 2026-07-15T09:00:00.0000000
```

Esse texto já está em horário de Brasília. A documentação de convertFromUtc diz o mesmo: o resultado vem sem o deslocamento do fuso. Se você passar esse valor adiante como se fosse UTC, o próximo passo vai tratá-lo como UTC e a hora fica errada.

## convertFromUtc e convertToUtc

Quando a origem é sempre UTC, convertFromUtc é mais curta, porque não pede o fuso de origem:

```
convertFromUtc('2026-11-02T11:30:00Z', 'E. South America Standard Time', 'dd/MM/yyyy HH:mm')
```

Ela faz o mesmo que o convertTimeZone acima. Eu não executei esta forma no fluxo de teste; o comportamento está descrito na documentação da Microsoft, com o exemplo convertFromUtc('2018-01-01T08:00:00.0000000Z', 'Pacific Standard Time') resultando em 2018-01-01T00:00:00.0000000.

O caminho inverso é convertToUtc: ele pega uma data no horário local (por exemplo, digitada por uma pessoa em um formulário) e leva para UTC. Exemplo da documentação: convertToUtc('01/01/2018 00:00:00', 'Pacific Standard Time') devolve 2018-01-01T08:00:00.0000000Z. Use quando precisar comparar com utcNow() ou gravar em UTC.

## Nomes de fuso: do Windows, não da IANA

Os três conversores recebem o nome de fuso do Windows, listado na página "Default Time Zones" da Microsoft. Nomes como America/Sao_Paulo não são os esperados. A página lista, para o Brasil, E. South America Standard Time, com UTC-03:00 e a descrição "Brasilia". A documentação da função ainda avisa que, em convertTimeZone, "você pode ter de remover a pontuação" do nome. Se der erro, teste o nome em uma ação Compose isolada.

Resultados reais de um fluxo de teste, convertendo 2026-07-15T12:00:00Z com formato HH:mm:

- E. South America Standard Time (Brasília): 09:00
- SA Eastern Standard Time (Fortaleza): 09:00

- Bahia Standard Time (Salvador): 09:00
- SA Western Standard Time (Manaus): 08:00

- Central Brazilian Standard Time (Cuiabá): 08:00
- SA Pacific Standard Time (Rio Branco): 07:00

- UTC: 12:00

Moral: o Brasil tem fusos diferentes, e "Brasília" não serve para quem está em Manaus ou Rio Branco. Se o fluxo atende o país todo, guarde o fuso de cada unidade ou usuário em uma coluna, em vez de fixar um nome na expressão.

## Horário de verão: o que muda e o que não muda

O nome "Standard Time" engana: as conversões respeitam o horário de verão dos países que o adotam. No mesmo teste, com 2026-07-15T12:00:00Z e 2026-01-15T12:00:00Z:

- Nova York (Eastern Standard Time): 08:00 em julho e 07:00 em janeiro
- Londres (GMT Standard Time): 13:00 em julho e 12:00 em janeiro

- Sydney (AUS Eastern Standard Time): 22:00 em julho e 23:00 em janeiro

Isso quer dizer que a diferença entre Brasília e Nova York, por exemplo, não é fixa: em julho Nova York fica 1 hora mais perto de Brasília que em janeiro. Por isso converta sempre com a data real do evento, nunca somando um número fixo de horas.

E o Brasil? O horário de verão foi encerrado no território nacional pelo Decreto nº 9.772, de 25 de abril de 2019, cujo artigo 1º diz que "fica encerrada a hora de verão no território nacional". No teste em 02/11/2026, a conversão de 11:30 UTC para Brasília deu 08:30, ou seja, UTC-3, sem ajuste. Se o seu fluxo trata datas anteriores a 2019, a regra da época não é a de hoje, e a conversão correta deve vir do fuso, não de um cálculo manual. Confira sempre a legislação vigente na fonte oficial; este guia não é orientação jurídica.

## Erros comuns

### 1. Somar ou subtrair 3 horas na mão

addHours(utcNow(), -3) dá o horário certo de Brasília hoje porque não há horário de verão no país, mas não serve para Nova York, Londres ou qualquer fuso que muda, e quebra se a regra mudar. Prefira convertTimeZone.

### 2. Tratar o horário local como se fosse UTC

Uma pessoa informa "02/11/2026 08:30" em um formulário. Se você passa esse texto para convertTimeZone(..., 'UTC', 'E. South America Standard Time'), o fluxo entende que 08:30 é UTC e devolve 05:30 (cálculo por UTC-3, não executado). O certo é a origem ser o fuso da pessoa, ou usar convertToUtc.

### 3. Reconverter um resultado sem Z

Como visto acima, o resultado sem formato vem sem Z e já está no fuso de destino. Converter de novo "de UTC" desloca a hora mais 3 horas para trás.

### 4. Formatar antes de calcular

Transformar a data em texto cedo demais faz você comparar textos, não datas. Mantenha o valor em ISO enquanto o fluxo calcula e use formatDateTime na última ação.

### 5. Códigos de formato curtos

No teste, formatDateTime com o formato H falhou: o erro diz que um formato de uma letra precisa ser um especificador padrão válido (como d ou g) ou um padrão personalizado (como MMMM dd, yyyy). Use HH para a hora de 00 a 23. Também lembre que mm é minuto e MM é mês: no teste, mm sobre 08:05:09 deu 05 e MM deu 11.

### 6. Dia e mês trocados na leitura

Antes de converter, a data precisa ser lida certo. No teste, parseDateTime('03/04/2026', 'pt-BR') deu 3 de abril (2026-04-03) e, com 'en-US', 4 de março (2026-03-04). Informe a cultura sempre que a data vier digitada.

## Receita pronta para um e-mail em horário de Brasília

- Guarde o valor original em UTC (o de utcNow() ou o da coluna do SharePoint).
- Na hora de mostrar, use convertTimeZone(valor, 'UTC', 'E. South America Standard Time', 'dd/MM/yyyy HH:mm').

- Se alguém digitou a data, leia com parseDateTime e a cultura certa e converta com convertToUtc antes de gravar.
- Teste com uma data de julho e outra de janeiro, para pegar problemas de horário de verão em fusos estrangeiros.

Para conferir o resultado sem rodar o fluxo, use o conversor de fuso horário (https://meajudaflow.com.br/tools/fuso-horario) do Me Ajuda Flow, que mostra a mesma hora em vários fusos e o nome do Windows de cada um. Para escolher o formato do texto, veja também o construtor de formato de data (https://meajudaflow.com.br/tools/formato-data) e a ferramenta de datas (https://meajudaflow.com.br/tools/datas).

Fontes oficiais:
- Referência de funções de expressão: convertTimeZone, convertFromUtc, convertToUtc, utcNow (Microsoft Learn): https://learn.microsoft.com/en-us/azure/logic-apps/workflow-definition-language-functions-reference
- Default Time Zones: nomes de fuso do Windows (Microsoft Learn): https://learn.microsoft.com/en-us/windows-hardware/manufacture/desktop/default-time-zones
- Decreto nº 9.772, de 25 de abril de 2019: encerra a hora de verão (Planalto): https://planalto.gov.br/ccivil_03/_ato2019-2022/2019/decreto/d9772.htm

## JWT: como ler um token e o que ele não garante

URL: https://meajudaflow.com.br/guias/jwt-como-ler-um-token-e-o-que-ele-nao-garante
Atualizado em: 2026-11-02

Um JWT parece um texto embaralhado, mas qualquer pessoa consegue ler o que há dentro dele. Veja como ele é montado, o que significa cada claim comum e por que conseguir ler o conteúdo não prova que o token é verdadeiro.

## As três partes do token

O formato mais comum de JWT é o JWS em serialização compacta, definido na RFC 7515: três blocos de texto separados por ponto, na forma cabeçalho.conteúdo.assinatura. Cada bloco é codificado em Base64URL. A RFC 7519 informa que o número de partes depende da representação: um JWT criptografado (JWE) tem cinco partes. Este guia trata do caso de três partes, que é o que você encontra na maioria dos cabeçalhos Authorization: Bearer.

- Header (cabeçalho): um JSON com metadados, principalmente alg, o algoritmo da assinatura, e typ, o tipo. A RFC 7515 exige que o alg esteja presente.
- Payload (conteúdo): um JSON com as claims, isto é, as afirmações sobre o usuário, o emissor, o prazo e o que mais a aplicação quiser incluir.

- Signature (assinatura): calculada sobre os dois primeiros blocos, exatamente como estão escritos, unidos por ponto. É ela que permite detectar adulteração, e só quem sabe validar com a chave correta consegue fazer isso.

## O que é Base64URL

É o Base64 com dois ajustes para poder viajar em URLs e cabeçalhos: o + vira -, o / vira _ e os = de preenchimento no fim são omitidos. A RFC 7515 define Base64url como a variante da RFC 4648 sem o preenchimento.

Teste real: o JSON {"a":"é>>?"} em Base64 comum vira eyJhIjoiw6k+Pj8ifQ==. Em Base64URL vira eyJhIjoiw6k-Pj8ifQ, com - no lugar do + e sem os dois = finais. Colar um trecho de JWT em um decodificador de Base64 comum pode falhar justamente por isso. Para essa conversão, use a ferramenta de Base64 (https://meajudaflow.com.br/tools/base64), que aceita as duas variantes.

Importante: Base64URL é só uma forma de escrever bytes. Não há chave, não há segredo. Quem tem o token tem o conteúdo.

## Exemplo: lendo um token fictício

Este token foi montado para o guia, com dados inventados e uma assinatura sem valor:

```
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwczovL2F1dGguZXhlbXBsby5jb20uYnIiLCJzdWIiOiJ1c2VyLTEwNDIiLCJhdWQiOiJhcGktcGVkaWRvcyIsImlhdCI6MTc5MzgzNjgwMCwibmJmIjoxNzkzODM2ODAwLCJleHAiOjE3OTM4NDA0MDAsIm5hbWUiOiJNYXJpYSBTb3V6YSJ9.YXNzaW5hdHVyYS1maWN0aWNpYS1uYW8tdmVyaWZpY2FkYQ
```

O decodificador do Me Ajuda Flow mostra o cabeçalho:

```
{
  "alg": "HS256",
  "typ": "JWT"
}
```

E o payload:

```
{
  "iss": "https://auth.exemplo.com.br",
  "sub": "user-1042",
  "aud": "api-pedidos",
  "iat": 1793836800,
  "nbf": 1793836800,
  "exp": 1793840400,
  "name": "Maria Souza"
}
```

Os campos de tempo são convertidos para datas legíveis: iat e nbf em 2026-11-05 00:00:00 UTC e exp em 2026-11-05 01:00:00 UTC. A diferença entre exp e iat é 1793840400 menos 1793836800, ou seja, 3600 segundos: o token dura uma hora.

## Claims comuns

As definições estão na seção 4.1 da RFC 7519. Todas são opcionais pela especificação, mas é comum que o sistema que valida exija algumas.

- iss (issuer): quem emitiu o token. No exemplo, https://auth.exemplo.com.br.
- sub (subject): o sujeito do token, normalmente um identificador do usuário.

- aud (audience): para quem o token foi emitido. Pela RFC 7519, quem recebe um token em que não está listado como destinatário deve rejeitá-lo.
- exp (expiration): a partir de quando o token não pode mais ser aceito.

- nbf (not before): antes desse momento o token não pode ser aceito.
- iat (issued at): quando o token foi emitido.

Os três campos de tempo são datas numéricas: segundos desde 1970-01-01 00:00:00 UTC, e não milissegundos. Um erro comum é tratar 1793840400 como milissegundos e concluir que a data é de janeiro de 1970.

## Decodificar não é validar

Esta é a ideia central. Decodificar é desfazer o Base64URL e ler o JSON, e qualquer pessoa faz isso sem chave nenhuma. Validar é conferir a assinatura com a chave certa, o algoritmo esperado e as claims (emissor, destinatário, prazos). A seção 7.2 da RFC 7519 lista esses passos e diz que, se qualquer um falhar, o JWT deve ser rejeitado.

Na prática, isso significa que um token legível pode ser falso. Quem montasse o JSON à mão e colocasse "sub": "user-1042" teria um token tão legível quanto o verdadeiro. O que o distingue é a assinatura, e o decodificador do site não a verifica: ele avisa isso, e informa também se o exp já passou pelo relógio do seu computador. Use a ferramenta de JWT (https://meajudaflow.com.br/tools/jwt) para inspecionar, nunca para decidir se alguém pode entrar.

## Riscos mais comuns

### Algoritmo none

A RFC 7519 (seção 6) descreve o JWT sem proteção: o cabeçalho traz "alg": "none" e a assinatura é vazia. Teste real com o decodificador do site, com um token assim:

```
eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJzdWIiOiJ1c2VyLTEwNDIiLCJhZG1pbiI6dHJ1ZX0.
```

Ele foi lido sem erro, mostrando "admin": true e a assinatura vazia. Se um servidor aceitasse esse token, qualquer um se declararia administrador. O OWASP orienta garantir que o parser não aceite "alg":"none", e a RFC 8725 (seção 3.2) diz que bibliotecas não devem gerar nem aceitar tokens assim, a menos que o chamador peça explicitamente. A RFC 8725 (seção 3.1) pede ainda que o chamador defina a lista de algoritmos aceitos, em vez de confiar no que o próprio token declara.

### Segredo fraco

Em algoritmos como HS256, a assinatura usa um segredo compartilhado. Um segredo curto ou previsível pode ser descoberto por tentativa e erro. A RFC 8725 (seção 3.5) diz que senhas memorizáveis por humanos não devem ser usadas diretamente como chave. O OWASP pede que o segredo seja gerado por um gerador criptograficamente seguro e tenha tamanho pelo menos igual ao da saída do algoritmo: 256 bits para HS256. Para gerar um segredo aleatório, a ferramenta de hash (https://meajudaflow.com.br/tools/hash) não é o caminho: hash não cria entropia. O correto é usar um gerador criptográfico do seu ambiente.

### Token em log e em outros lugares

Quem lê o token lê as claims, e um token válido ainda dentro do prazo funciona como credencial. O OWASP observa que as claims ficam expostas em logs de aplicação, no armazenamento do navegador e em cabeçalhos de referência. Como regra de bom senso (não é uma exigência dessas fontes), evite registrar o token inteiro em logs, e-mails, tickets e prints. Se for preciso diagnosticar, registre apenas o sub e o exp, ou os primeiros caracteres. Se um token válido vazou, trate como credencial exposta e siga o procedimento de revogação do sistema que o emitiu.

### Audience e emissor ignorados

Uma assinatura válida não basta. Se o seu serviço aceita um token emitido para outra API, ele está aceitando algo que não era para ele. A RFC 8725 (seção 3.9) pede que a claim aud seja validada por quem recebe.

## O que nunca colocar no payload

O OWASP resume: um JWT assinado oferece integridade e autenticidade, mas não confidencialidade. O payload é apenas codificado, não criptografado. A RFC 7519 (seção 12) exige que, havendo informação sensível, sejam tomadas medidas para evitar sua divulgação a terceiros. O OWASP considera omitir dados sensíveis a forma mais simples de reduzir o problema e sugere manter esses dados no servidor, atrás de uma referência opaca.

- Senhas, códigos de verificação e chaves de API.
- Números de documento, cartão de pagamento, dados de saúde e outros dados pessoais que não sejam indispensáveis.

- Qualquer coisa que você não aceitaria ver em uma captura de tela do token.

Prefira identificadores ("sub": "user-1042") a dados ("cpf": "..."). Se for realmente necessário esconder o conteúdo, existe o JWE, token criptografado, que está fora do escopo deste guia.

## Checklist rápido ao receber um JWT

- Decodifique só para entender o conteúdo e conferir os prazos.
- Valide a assinatura em código, com biblioteca madura, com o algoritmo definido por você e a chave do emissor.

- Confira iss, aud, exp e nbf.
- Não guarde nem registre o token além do necessário.

Para inspecionar um token agora, abra a ferramenta de JWT (https://meajudaflow.com.br/tools/jwt). Ela decodifica no navegador e avisa que a assinatura não foi verificada.

Fontes oficiais:
- RFC 7519: JSON Web Token (JWT): https://www.rfc-editor.org/rfc/rfc7519
- RFC 7515: JSON Web Signature (JWS): https://www.rfc-editor.org/rfc/rfc7515
- RFC 8725: JSON Web Token Best Current Practices: https://www.rfc-editor.org/rfc/rfc8725
- JSON Web Token Cheat Sheet (OWASP): https://cheatsheetseries.owasp.org/cheatsheets/JSON_Web_Token_Cheat_Sheet.html

## Base64 não é criptografia

URL: https://meajudaflow.com.br/guias/base64-nao-e-criptografia
Atualizado em: 2026-11-02

Base64 deixa um texto ilegível a olho nu, e por isso muita gente acha que ele protege o conteúdo. Não protege: é só uma forma de escrever bytes com letras e números, e qualquer pessoa desfaz em um clique. Veja o que ele faz, onde ele é útil e o que usar quando o assunto é segredo.

## O que o Base64 é de verdade

Base64 é uma codificação: uma regra pública para representar bytes quaisquer usando apenas 64 caracteres imprimíveis. A regra está na RFC 4648, que usa um subconjunto de 65 caracteres do US-ASCII (as letras de A a Z e de a a z, os dígitos de 0 a 9, o + e a /, mais o = como preenchimento). Cada grupo de 3 bytes (24 bits) vira 4 caracteres.

Não existe chave, senha ou segredo no processo. Quem conhece a regra, e ela é pública, desfaz a conversão. A própria RFC avisa na seção de segurança que a codificação esconde visualmente informações fáceis de reconhecer, mas não oferece nenhuma confidencialidade computacional. A senha é o exemplo que o texto cita.

Exemplo real, rodado com o código do Me Ajuda Flow. O texto usuario:SenhaForte123 vira:

```
dXN1YXJpbzpTZW5oYUZvcnRlMTIz
```

E ao decodificar essa mesma sequência volta exatamente usuario:SenhaForte123, sem chave nenhuma. Parece embaralhado, mas não está protegido.

## Quanto o Base64 aumenta o tamanho

Como 3 bytes viram 4 caracteres, o resultado fica cerca de 33% maior (4 dividido por 3). Quando o tamanho original não é múltiplo de 3, o final recebe um ou dois sinais = de preenchimento, então a conta exata é: tamanho codificado = arredondar para cima (bytes / 3) x 4.

- hello (5 bytes) vira aGVsbG8= (8 caracteres).
- {"id":42} (9 bytes) vira eyJpZCI6NDJ9 (12 caracteres, sem preenchimento).

- Um arquivo de 3000 bytes vira 4000 caracteres. Um de 300 bytes vira 400.

Na prática, um PDF de 3 MB enviado como Base64 dentro de um JSON ocupa por volta de 4 MB. Isso importa quando o serviço de destino tem limite de tamanho de requisição: confira o limite na documentação do serviço, contando o tamanho já codificado.

## Base64URL: a variante para endereços e tokens

Os caracteres + e / têm significado especial em endereços (URLs) e nomes de arquivo. Por isso a RFC 4648 define, na seção 5, uma variante "URL and filename safe": é idêntica à padrão, exceto pelos valores 62 e 63, que passam a ser - (hífen) e _ (sublinhado). A RFC também diz que o = costuma ser codificado com porcentagem em URIs e que, se o tamanho dos dados for conhecido, o preenchimento pode ser omitido.

Exemplo real: o texto >>>??? em Base64 padrão é Pj4+Pz8/. Em Base64URL, sem preenchimento, fica Pj4-Pz8_. Os bytes são os mesmos, só dois caracteres mudam. O botão de Base64 URL-safe da ferramenta do site gera exatamente essa forma.

É o formato usado nas partes de um JWT (cabeçalho e payload). Isso explica por que um JWT começa quase sempre com eyJ: é o início de um JSON que abre com {". Decodificar um JWT mostra o conteúdo, mas não prova que ele é autêntico.

## Quando usar Base64

Use quando precisar colocar bytes em um lugar que só aceita texto:

- Anexos e arquivos dentro de JSON. APIs costumam receber o conteúdo do arquivo como uma string Base64 no corpo da requisição.
- Imagens embutidas em HTML e CSS, com o prefixo data:image/png;base64,.

- Cabeçalhos e tokens que precisam trafegar sem caracteres problemáticos.

O motivo é compatibilidade, nunca sigilo. Se o texto Base64 vazar, o conteúdo vaza junto.

## Erros comuns

### Senha em Base64 em fluxo ou em requisição HTTP

O erro mais frequente: guardar uma senha, uma chave de API ou um token "em Base64 para não ficar visível" em uma variável do fluxo, em uma planilha ou em um corpo HTTP. Quem abrir o histórico de execução ou interceptar a requisição decodifica em segundos, como no exemplo da seção inicial. Segredos devem ficar em um local próprio para isso, não em texto disfarçado.

### Confundir Base64 com hash

Hash não tem volta, Base64 tem. Se você precisa comparar uma senha sem guardá-la, o caminho é um hash próprio para senhas, não codificação.

### Quebrar o texto ao copiar

Espaços, quebras de linha ou um caractere trocado fazem a decodificação falhar. No decodificador do site, um caractere fora do alfabeto gera uma mensagem como: o caractere $ (posição 4) não existe em Base64.

## Decodificar em Power Automate

A documentação da Microsoft lista as funções base64 (codifica uma string), base64ToString (decodifica para texto) e base64ToBinary (decodifica para binário). Elas vêm da linguagem de expressões de fluxos de trabalho, a mesma documentada para o Logic Apps. Os exemplos da própria Microsoft:

```
base64('hello')
```

Retorna "aGVsbG8=".

```
base64ToString('aGVsbG8=')
```

Retorna "hello". Resultado igual ao que a ferramenta do Me Ajuda Flow produz para esse texto.

- Use base64ToString quando o conteúdo é texto, e base64ToBinary quando é um arquivo que você vai enviar ou gravar, como um PDF.
- A Microsoft indica usar base64ToString no lugar de decodeBase64, que está obsoleta.

- A documentação informa que o Logic Apps pode converter automaticamente em alguns casos, sem precisar das funções, e que, ao inserir essas funções no designer, a exibição pode mudar. Isso afeta só a visualização da função, não o efeito. Confira a nota completa na página da Microsoft.
- Se o conteúdo vier em Base64URL, como o payload de um JWT, troque - por + e _ por /, e complete o = no final antes de decodificar. Não afirmamos aqui que a função aceite a variante URL diretamente: teste com um valor seu.

## O que usar para proteger de verdade

A escolha depende do que você precisa garantir:

- Sigilo do conteúdo: criptografia de verdade, com chave. Em trânsito, HTTPS. Em repouso, a criptografia do serviço que guarda os dados.
- Segredos de fluxos e aplicativos (senhas, chaves de API): um cofre de segredos ou o mecanismo de variáveis seguras da plataforma, em vez de texto em variáveis comuns. Confira os recursos disponíveis no seu ambiente.

- Integridade (o arquivo não foi alterado): um hash do conteúdo, comparado com o valor esperado. Veja a ferramenta de hash (https://meajudaflow.com.br/tools/hash).
- Autenticidade (quem emitiu): assinatura digital ou a verificação da assinatura do token, que a decodificação do JWT não faz.

- Senhas de usuários: algoritmo de hash próprio para senhas, com sal, nunca Base64.

Este guia é informativo e não substitui a política de segurança da sua empresa nem a orientação de um especialista.

## Checklist rápido

- Se o texto parece embaralhado e termina com = ou ==, provavelmente é Base64: decodifique antes de achar que é criptografia.
- Se é um segredo, tire do Base64 e mude a senha se ela já circulou assim.

- Se precisa enviar arquivo em JSON, use Base64 e conte 33% a mais no limite de tamanho.
- Se contém - e _ e começa com eyJ, é Base64URL, provavelmente de um JWT.

Para codificar ou decodificar na hora, inclusive em Base64URL, use a ferramenta Base64 (https://meajudaflow.com.br/tools/base64) do Me Ajuda Flow. Para ler o cabeçalho e o payload de um token, veja o decodificador de JWT (https://meajudaflow.com.br/tools/jwt), e para gerar o resumo de um conteúdo, a ferramenta de hash (https://meajudaflow.com.br/tools/hash).

Fontes oficiais:
- RFC 4648: The Base16, Base32, and Base64 Data Encodings: https://www.rfc-editor.org/rfc/rfc4648
- Referência de funções da linguagem de definição de fluxo de trabalho (Microsoft Learn): https://learn.microsoft.com/en-us/azure/logic-apps/workflow-definition-language-functions-reference

## Senhas seguras: como criar e guardar sem complicar

URL: https://meajudaflow.com.br/guias/senhas-seguras-como-criar-e-guardar
Atualizado em: 2026-11-02

Uma senha forte não é a cheia de símbolos que você não consegue lembrar. É a longa, imprevisível e usada em um lugar só. Veja a conta por trás disso, o que as normas atuais recomendam e onde não guardar senhas.

## Comprimento vence complexidade

Durante anos a regra foi "misture maiúscula, número e símbolo". O NIST, órgão de padrões dos Estados Unidos, mudou isso. Na SP 800-63B, quem verifica senhas não deve impor regras de composição (como exigir mistura de tipos de caractere) e não deve exigir troca periódica, só a troca quando há suspeita de comprometimento. Para senhas usadas sozinhas, o mínimo é 15 caracteres. Se a senha só é usada junto com outro fator, o mínimo cai para 8. O NIST também recomenda aceitar tamanhos de pelo menos 64 caracteres e permitir gerenciadores de senhas e colar o texto no campo.

O motivo é prático: regras de composição levam as pessoas a criar Senha@2026, que atende a regra e é fácil de adivinhar. O NCSC, centro de cibersegurança do Reino Unido, diz algo parecido: o conselho antigo de usar caracteres aleatórios, símbolos e números não ajuda, porque ninguém memoriza muitas senhas assim, e trocar letras por números parecidos (a por 4, o por 0) dá pouca proteção, pois os atacantes conhecem o truque.

## A conta: entropia

Entropia mede, em bits, quantas tentativas um atacante precisaria fazer, no pior caso, para acertar uma senha criada de forma aleatória. A fórmula é:

```
bits = comprimento × log2(tamanho do conjunto de caracteres)
```

Cada bit a mais dobra o número de possibilidades. Os valores abaixo foram calculados com o código do gerador de senha do Me Ajuda Flow (conjunto de 74 caracteres: 26 minúsculas, 26 maiúsculas, 10 dígitos e 12 símbolos):

- 8 letras minúsculas (conjunto de 26): 37,6 bits, cerca de 2,1 × 1011 combinações. A ferramenta classifica como "fraca".
- 8 caracteres de qualquer tipo (74): 49,7 bits, cerca de 9 × 1014 combinações. "Razoável".

- 16 letras minúsculas (26): 75,2 bits.
- 16 caracteres de qualquer tipo (74): 99,4 bits.

Compare os dois primeiros e o terceiro. Dobrar o tamanho de 8 para 16 usando só minúsculas (75,2 bits) rende bem mais do que acrescentar maiúsculas, números e símbolos a uma senha de 8 (49,7 bits). Por isso o comprimento é a alavanca principal.

### O que a fórmula não cobre

A conta só vale se a senha foi sorteada. Se ela foi inventada por você, como Flamengo2019!, a entropia real é muito menor do que o tamanho sugere, porque atacantes testam primeiro palavras comuns, datas e variações. A Cartilha do CERT.br diz o mesmo: serviços que classificam senhas podem chamar de "muito forte" uma senha que contém dados pessoais que o serviço desconhece, mas um atacante pode conhecer. Evite nomes, datas, placas, telefones e sequências de teclado como 1qaz2wsx.

## Frase-senha: a opção memorizável

Quando você precisa lembrar a senha (a do gerenciador, a do computador), o NCSC recomenda combinar três palavras aleatórias, como no exemplo do próprio órgão, applenemobiro. Palavras escolhidas por você ("meu time + meu pet") não valem: têm de ser aleatórias.

A conta é a mesma, mas agora o "conjunto" é a lista de palavras. O gerador do Me Ajuda Flow usa uma lista de 256 palavras, ou seja, 8 bits por palavra:

- 4 palavras: 32 bits. A ferramenta classifica como "fraca". Com uma lista tão pequena, quatro palavras não bastam.
- 5 palavras: 40 bits.

- 6 palavras, com inicial maiúscula e um dígito no final, como Campo-Banana-Feijao-Peixe-Cerveja-Carne-6 (sorteada pelo gerador): 51,3 bits, "razoável".

Em uma lista maior a conta melhora. Se a lista tivesse 7.776 palavras, cada palavra valeria cerca de 12,9 bits (log2 de 7.776) e 6 palavras chegariam a perto de 77 bits. A lição: o tamanho da lista e o número de palavras importam, e use sempre mais palavras do que parece necessário.

## Nunca reutilizar

Uma senha forte usada em dez sites tem a segurança do site mais fraco entre os dez. Se um deles vaza, os atacantes tentam o mesmo e-mail e a mesma senha nos outros serviços. A Cartilha do CERT.br resume o risco: basta ao atacante descobrir a senha de uma conta para acessar todas as outras em que ela foi reutilizada. A orientação é nunca reutilizar senhas de e-mail e de internet banking, e não misturar senha pessoal com profissional. Nota: a versão 4.0 da Cartilha é de 2012. Em outros pontos, como a troca periódica, o NIST hoje é mais atual.

## Gerenciador de senhas

É a forma realista de ter uma senha única e longa para cada conta. O NCSC explica que o gerenciador guarda as credenciais em um cofre aberto por uma senha mestra, o que facilita usar senhas únicas e difíceis de adivinhar e reduz os "atalhos inseguros", como reutilizar senhas. O mesmo guia reconhece que gerenciadores podem ter vulnerabilidades e são alvo natural de ataque, e conclui que os benefícios compensam. A Cartilha cita 1Password e KeePass como exemplos e dá cuidados que continuam valendo:

- Faça uma senha mestra forte (use frase-senha) e não a esqueça: sem ela, as senhas guardadas ficam perdidas.
- Instale o programa a partir de uma fonte confiável e mantenha-o atualizado.

- Não dependa do gerenciador para entrar na conta de e-mail de recuperação, para ter uma saída se perder a senha mestra.

Salvar senhas no navegador sem chave mestra é arriscado, segundo a Cartilha, porque códigos maliciosos ou outra pessoa com acesso ao computador podem lê-las.

## Verificação em duas etapas

Mesmo uma boa senha pode vazar por phishing ou por um site comprometido. A segunda etapa (um código, um aplicativo ou uma chave física) faz com que a senha, sozinha, não baste para entrar. O NIST trata isso como autenticação multifator e, como visto acima, aceita senhas mais curtas (mínimo de 8) quando ela é usada junto com outro fator. Isso não é motivo para encurtar a sua: ative a segunda etapa e mantenha a senha longa. Comece pelo e-mail, que serve para recuperar todas as outras contas, e por banco e serviços de trabalho. Os tipos de segundo fator diferem em força, e o detalhe está na SP 800-63B.

## Onde não guardar senhas

Os erros mais comuns em equipes, que o detector de segredos do Me Ajuda Flow procura:

- Planilha compartilhada com uma coluna "senha". Quem abre o arquivo, ou quem recebe o link por engano, vê tudo. O histórico de versões mantém senhas antigas mesmo depois de apagadas da célula.
- Fluxos de automação com a senha digitada dentro de uma ação ou de uma URL (https://usuario:senha@servidor). Qualquer pessoa com acesso de edição ao fluxo, ou a uma exportação dele, consegue lê-la. Use o cofre ou as variáveis seguras da plataforma e confirme na documentação dela como proteger entradas e saídas.

- Código, repositório e chat. Uma senha enviada por mensagem ou commitada continua no histórico. Se isso aconteceu, troque a senha: apagar o texto não basta.
- Papel colado no monitor. O NCSC aceita anotar senhas em papel desde que fique em local seguro, e a Cartilha prefere o papel em gaveta trancada a uma senha fraca. Sob o monitor ou sobre a mesa, não.

Se precisar entregar uma senha a alguém, a Cartilha é direta sobre o caso pessoal: não forneça suas senhas a outra pessoa, em hipótese alguma. Em equipes, o caminho é uma conta individual por pessoa ou o compartilhamento dentro de um gerenciador corporativo.

## Roteiro rápido

- Instale um gerenciador de senhas e proteja-o com uma frase-senha longa e aleatória.
- Para cada conta nova, deixe o gerenciador gerar uma senha de 16 caracteres ou mais, única.

- Ative a verificação em duas etapas, primeiro no e-mail, no banco e nos serviços de trabalho.
- Troque a senha quando houver suspeita de vazamento, não por calendário.

- Procure senhas esquecidas em planilhas, fluxos e código, e troque as que encontrar.

Para gerar senhas e frases com a conta da entropia na tela, use o gerador de senha (https://meajudaflow.com.br/tools/gerador-de-senha) do Me Ajuda Flow, que sorteia tudo no seu navegador. Para procurar senhas esquecidas em textos, fluxos e configurações, veja o detector de segredos (https://meajudaflow.com.br/tools/detector-de-segredos). E, se o assunto for guardar uma impressão digital de um texto sem guardar o texto, veja a ferramenta de hash (https://meajudaflow.com.br/tools/hash).

Fontes oficiais:
- NIST SP 800-63B: Digital Identity Guidelines, Authentication and Authenticator Management: https://pages.nist.gov/800-63-4/sp800-63b.html
- NCSC (Reino Unido): Use three random words to create a strong password: https://www.ncsc.gov.uk/collection/top-tips-for-staying-secure-online/three-random-words
- NCSC (Reino Unido): Password manager buyers' guide: https://www.ncsc.gov.uk/collection/passwords/password-manager-buyers-guide
- Cartilha de Segurança para Internet, versão 4.0, cap. 8 Contas e senhas (CERT.br / CGI.br): https://cartilha.cert.br/livro/cartilha-seguranca-internet.pdf

## Juros compostos: como calcular e conferir uma simulação

URL: https://meajudaflow.com.br/guias/juros-compostos-como-calcular-e-conferir
Atualizado em: 2026-11-02

Juros compostos são juros sobre juros, e é por isso que 1% ao mês não dá 12% ao ano. Veja a fórmula, como converter taxa mensal em anual (e o contrário), o efeito dos aportes e um roteiro para conferir qualquer simulação.

## O que são juros compostos

Segundo o Glossário Simplificado de Termos Financeiros do Banco Central, nos juros compostos o valor dos juros de um período (dia, mês, ano) é acumulado ao saldo da dívida ou do investimento e entra no cálculo dos juros do período seguinte. O mesmo glossário afirma que a imensa maioria das operações do mercado, como aplicações, empréstimos e financiamentos, usa esse regime. Nos juros simples, ao contrário, os juros de cada período são sempre calculados sobre o valor inicial.

A fórmula do valor final, sem aportes, é:

```
VF = VP × (1 + i)^n
```

onde VP é o valor inicial, i é a taxa por período (em decimal, 1% = 0,01) e n é o número de períodos. O ponto que mais gera erro: i e n precisam estar na mesma unidade. Taxa ao mês pede prazo em meses.

## Exemplo: R$ 1.000 a 1% ao mês

Resultados obtidos com o código da calculadora de juros compostos do Me Ajuda Flow:

- Mês 1: juros de R$ 10,00, saldo de R$ 1.010,00.
- Mês 2: juros de R$ 10,10 (1% de R$ 1.010,00), saldo de R$ 1.020,10.

- Mês 3: juros de R$ 10,20, saldo de R$ 1.030,30.
- Mês 12: saldo de R$ 1.126,84, ou seja, R$ 126,84 de juros.

Note que os juros crescem todo mês, porque a base de cálculo cresce. Em juros simples, seriam R$ 10,00 todo mês e R$ 1.120,00 no fim de 12 meses.

## Por que 1% ao mês não é 12% ao ano

Dividir ou multiplicar a taxa linearmente (12% ao ano dividido por 12 dá 1% ao mês) vale para juros simples. Em juros compostos, a conversão correta usa potência. A taxa anual equivalente a uma taxa mensal i é:

```
anual = (1 + i)^12 - 1
```

E o caminho inverso, da taxa anual para a mensal equivalente, é:

```
mensal = (1 + anual)^(1/12) - 1
```

Valores calculados com as funções do projeto:

- 1% ao mês equivale a 12,68% ao ano.
- 2% ao mês equivale a 26,82% ao ano.

- 12% ao ano equivale a 0,9489% ao mês, e não a 1%.
- 10% ao ano equivale a 0,7974% ao mês.

Prova pelo caminho contrário: R$ 1.000 a 0,9489% ao mês durante 12 meses chegam a R$ 1.120,00, exatamente 12% ao ano. Por isso, quando um contrato ou um anúncio trouxer taxa mensal e anual lado a lado, confira se a anual é a equivalente (12,68% para 1% ao mês) ou apenas a mensal multiplicada por 12. As duas aparecem na prática, e o texto do contrato deve dizer qual foi usada.

## Aportes mensais

Com aporte fixo PMT ao fim de cada mês, o valor final fica:

```
VF = VP × (1 + i)^n + PMT × ((1 + i)^n - 1) / i
```

Essa versão supõe que o aporte entra no fim do mês, depois dos juros daquele mês. Se a sua simulação põe o aporte no início, o resultado será maior, e a diferença vem só dessa convenção.

Exemplo calculado: R$ 1.000 iniciais mais R$ 200 por mês, a 1% ao mês, por 12 meses:

- Total investido: R$ 3.400,00 (1.000 + 12 × 200).
- Saldo final: R$ 3.663,33.

- Juros acumulados: R$ 263,32.

Só com os aportes, sem valor inicial, são R$ 2.400,00 investidos e R$ 2.536,49 no fim, ou R$ 136,49 de juros. Aportes recentes rendem pouco, porque tiveram poucos meses de juros. O efeito pesa mesmo em prazos longos.

## Juros compostos contra juros simples

O próprio Glossário do Banco Central traz um exemplo de dívida: R$ 1.000 no rotativo a 10% ao mês. No segundo mês, os juros de 10% incidem sobre R$ 1.100 e a dívida vai a R$ 1.210. Em 12 meses, o glossário informa R$ 3.138,43 em juros compostos contra R$ 2.200,00 em juros simples, uma diferença de R$ 938,43.

Refazendo o exemplo no código do projeto: dois meses dão R$ 1.210,00, como no glossário. Em 12 meses, a fórmula fechada dá R$ 3.138,43, igual ao glossário, e a simulação mês a mês dá R$ 3.138,44. A diferença de um centavo existe porque a simulação arredonda os juros de cada mês para centavos, como faz uma parcela real, e a fórmula não arredonda nada. Em uma conferência, uma diferença de poucos centavos costuma ser arredondamento, não erro.

Outra observação do glossário: com um único período de capitalização, juros simples e compostos dão o mesmo valor. A diferença só aparece a partir do segundo período.

## Como conferir uma simulação

- Unidades iguais. Taxa ao mês com prazo em meses. Se a taxa é anual, converta com (1 + anual)^(1/12) - 1 antes de simular em meses.
- Taxa em decimal. Use 0,01, não 1, na fórmula. Esquecer de dividir por 100 é o erro mais comum em planilha.

- Primeiro mês. Calcule à mão: valor inicial vezes a taxa. R$ 1.000 a 1% dá R$ 10,00. Se o primeiro mês já difere, o problema é de entrada.
- Fórmula fechada. Compare o saldo final com VP × (1 + i)^n. Diferença de centavos é arredondamento. Diferença de reais indica outra taxa, outro prazo ou outra convenção de aporte.

- Aporte no fim ou no início. Descubra qual convenção a ferramenta usa antes de comparar duas simulações.
- Taxas e impostos. A fórmula é bruta. Tarifas, IOF, imposto de renda e inflação mudam o resultado real e dependem de cada produto. Confirme essas regras na fonte do produto.

## Financiamento: o mesmo princípio

A Calculadora do Cidadão do Banco Central descreve o financiamento com prestações fixas como regime de juros compostos com capitalização mensal. A relação publicada é q0 = ((1 - (1 + j)^-n) / j) × p, em que q0 é o valor financiado, j a taxa mensal, n o número de meses e p a prestação. A página explica que a taxa j é obtida por aproximação a partir do valor da prestação. Ou seja, a mesma lógica da potência vale quando você descobre a taxa efetiva de uma parcela anunciada.

## Uma regra para guardar

Em juros compostos, tempo pesa mais que valor. R$ 100 a 1% ao mês por 120 meses chegam a R$ 330,04, mais que o triplo, sem nenhum aporte. Isso vale para investimento, e vale com a mesma força contra quem deve: dívida em atraso a juros altos cresce do mesmo jeito.

Para simular o seu caso, com valor inicial, aporte, taxa mensal ou anual e tabela mês a mês, use a ferramenta Juros compostos (https://meajudaflow.com.br/tools/juros-compostos) do Me Ajuda Flow. Para converter percentuais, veja Porcentagem (https://meajudaflow.com.br/tools/porcentagem), e para prestações de parcelamento, Financiamento (https://meajudaflow.com.br/tools/financiamento).

Fontes oficiais:
- Glossário Simplificado de Termos Financeiros (Banco Central do Brasil): https://www.bcb.gov.br/content/cidadaniafinanceira/documentos_cidadania/Informacoes_gerais/glossario_cidadania_financeira.pdf
- Calculadora do Cidadão: metodologia do financiamento com prestações fixas (Banco Central do Brasil): https://www3.bcb.gov.br/CALCIDADAO/publico/exibirMetodologiaFinanciamentoPrestacoesFixas.do?method=exibirMetodologiaFinanciamentoPrestacoesFixas

## Como conferir o saldo devedor de um financiamento de consumo

URL: https://meajudaflow.com.br/guias/saldo-devedor-financiamento-como-conferir
Atualizado em: 2026-11-02

O banco informou quanto falta para quitar e você quer saber se o número faz sentido. Com valor financiado, parcela e prazo, dá para refazer a conta, achar a taxa implícita e comparar com o valor pedido.

## O que é o saldo devedor

Saldo devedor é o que você ainda deve de principal, no dia em que a conta é feita. Não é a soma das parcelas que faltam. Cada parcela de um financiamento com parcelas fixas (tabela Price) tem duas partes: os juros do mês, calculados sobre o saldo anterior, e a amortização, que é o que realmente abate a dívida. No começo, a maior parte da parcela é juros. Por isso, depois de pagar um terço do prazo, o saldo ainda é bem maior que um terço do valor financiado.

Este guia usa o modelo de parcelas iguais, sem carência, com a primeira parcela um mês após a liberação. Seu contrato pode ter IOF e tarifas financiados, carência ou data de vencimento diferente. Nesse caso, o resultado abaixo é uma referência para conversar com o banco, não o valor oficial.

## O exemplo completo

Contrato fictício: R$ 30.000,00 financiados, 36 parcelas de R$ 1.120,00. Já foram pagas 12 parcelas. Os números abaixo foram calculados com o código da ferramenta de saldo devedor de CDC (https://meajudaflow.com.br/tools/saldo-devedor-cdc) do Me Ajuda Flow, com juros de cada mês arredondados ao centavo.

### 1. Taxa implícita

Se o contrato não mostra a taxa, ela sai da combinação valor, parcela e prazo: é a taxa mensal que faz 36 parcelas de R$ 1.120,00 valerem exatamente R$ 30.000,00 hoje. Resultado: 1,6944% ao mês, cerca de 22,34% ao ano (composta). O total pago seria R$ 40.320,00, dos quais R$ 10.320,00 são juros.

### 2. Primeiras linhas da tabela

- Parcela 1: juros R$ 508,32 (1,6944% de R$ 30.000,00), amortização R$ 611,68, saldo R$ 29.388,32.
- Parcela 2: juros R$ 497,95, amortização R$ 622,05, saldo R$ 28.766,27.

- Parcela 12: juros R$ 384,14, amortização R$ 735,86, saldo R$ 21.935,62.

Veja o contraste: pagas 12 parcelas (R$ 13.440,00 desembolsados), o principal caiu apenas R$ 8.064,38.

### 3. Saldo após k parcelas

É a última coluna da linha k: R$ 21.935,62 após a parcela 12. Com a planilha do banco ou a sua, a conferência é simples: saldo anterior vezes (1 + taxa), menos a parcela.

### 4. Valor presente das parcelas restantes

Faltam 24 parcelas de R$ 1.120,00, ou R$ 26.880,00 em valores nominais. Quitando hoje, a ideia do desconto é trazer cada parcela a valor presente pela taxa do contrato. O resultado foi R$ 21.935,63, a mesma conta do saldo, com 1 centavo de diferença por arredondamento. A diferença entre os R$ 26.880,00 nominais e esse valor, R$ 4.944,37, é a parcela de juros futuros que deixa de ser cobrada. É esse raciocínio que você deve esperar ver refletido no valor de quitação.

## Amortização extra: reduzir prazo ou reduzir parcela

Suponha que, depois da parcela 12, você amortize R$ 5.000,00 de uma vez. O saldo cai para R$ 16.935,62. Duas escolhas, calculadas com a mesma taxa:

- Reduzir o prazo (manter a parcela de R$ 1.120,00): o financiamento acaba em 18 meses em vez de 24, com a última parcela de R$ 693,07. A economia de juros é de R$ 2.146,93.
- Reduzir a parcela (manter 24 meses): a parcela vai a R$ 864,71, R$ 255,29 a menos. A economia de juros é de R$ 1.127,02.

Em geral, reduzir o prazo economiza mais, porque a dívida deixa de render juros mais cedo. Reduzir a parcela alivia o caixa mensal. A escolha depende do seu orçamento, e o contrato diz como o banco aplica a amortização, então confirme com ele antes de pagar.

## O direito à liquidação antecipada

O art. 52, §2º, do Código de Defesa do Consumidor, no texto compilado do Planalto, assegura ao consumidor a liquidação antecipada do débito, total ou parcialmente, com redução proporcional dos juros e demais acréscimos. O caput do mesmo artigo exige que, em crédito e financiamento, o fornecedor informe previamente o preço em moeda corrente, os juros de mora e a taxa efetiva anual, os acréscimos legais, o número e a periodicidade das prestações e o total a pagar, com e sem financiamento. Este guia não é aconselhamento jurídico: em caso de divergência, procure o banco, o Procon ou um advogado.

## O que pedir ao banco

- O demonstrativo detalhado da quitação: saldo, juros, encargos e a data de validade do valor.
- A taxa de juros do contrato e a forma como o desconto dos juros futuros foi calculado.

- O valor financiado na liberação, incluindo IOF, tarifas e seguros, se foram embutidos.
- A tabela de parcelas (planilha de amortização), para comparar linha a linha.

- Em amortização parcial, se o abatimento reduz o prazo ou a parcela.

## Como conferir o número do banco

- Cole valor financiado, prazo, parcela e parcelas pagas na ferramenta e anote a taxa implícita. Se ela for muito diferente da taxa do contrato, há algo embutido (tarifa, seguro, IOF) ou o contrato não é de parcelas iguais.
- Compare o saldo da linha k com o valor de quitação do banco. Diferenças pequenas vêm de arredondamento e da data; diferenças grandes pedem explicação por escrito.

- Se quiser uma segunda checagem, a calculadora do cidadão do Banco Central resolve um dos quatro campos (meses, taxa mensal, prestação, valor financiado) a partir dos outros três, para prestações fixas.

Se o valor exigido para quitar for próximo ao das parcelas nominais restantes (aqui, perto dos R$ 26.880,00), vale pedir a explicação do desconto antes de pagar.

Para refazer essa conta com os seus números, use a ferramenta saldo devedor de CDC (https://meajudaflow.com.br/tools/saldo-devedor-cdc). Para simular parcelas de um novo financiamento, veja financiamento (https://meajudaflow.com.br/tools/financiamento), e para entender o efeito do tempo sobre os juros, juros compostos (https://meajudaflow.com.br/tools/juros-compostos).

Fontes oficiais:
- Código de Defesa do Consumidor, art. 52 (Planalto): https://www.planalto.gov.br/ccivil_03/leis/l8078compilado.htm
- Calculadora do cidadão: financiamento com prestações fixas (Banco Central do Brasil): https://www3.bcb.gov.br/CALCIDADAO/publico/exibirFormFinanciamentoPrestacoesFixas.do?method=exibirFormFinanciamentoPrestacoesFixas

## Webhook do Pix: como ler e validar o corpo do aviso

URL: https://meajudaflow.com.br/guias/webhook-do-pix-como-ler-e-validar-o-corpo
Atualizado em: 2026-11-09

Quando um Pix cai na sua chave, o banco avisa o seu sistema com uma requisição. O corpo parece simples, mas a maior parte dos problemas vem de três detalhes: o valor é texto, o aviso traz uma lista e o horário vem em UTC.

## O que o webhook faz

Receber Pix por uma API de banco ou de provedor de pagamento significa que o seu sistema não precisa ficar perguntando "já pagaram?". Você cadastra um endereço de notificação para a sua chave e o banco chama esse endereço quando algo acontece. Segundo a especificação da API Pix, o cadastro é um PUT /webhook/{chave}, e os avisos chegam por POST em {seu endereço}/pix.

Há dois motivos para o aviso: um ou mais Pix recebidos nessa chave, e uma devolução que chegou a um status final (DEVOLVIDO ou NAO_REALIZADO). O prazo é definido por cada banco, e o seu endereço deve responder 200 para confirmar o recebimento.

## Como é o corpo

É um objeto com uma única chave, pix, cujo valor é uma lista. O banco pode juntar vários Pix da mesma chave em um aviso só. Este é o formato, com base no exemplo da própria especificação:

```
{
  "pix": [
    {
      "endToEndId": "E87654321202009091221dfghi123456",
      "txid": "971122d8f37211eaadc10242ac120002",
      "valor": "110.00",
      "horario": "2020-09-09T20:15:00.358Z",
      "infoPagador": "0123456789"
    }
  ]
}
```

| Campo | O que é | Cuidado |
| --- | --- | --- |
| endToEndId | Identificador do Pix de ponta a ponta (32 caracteres alfanuméricos) | Use como chave única do pagamento no seu sistema. |
| txid | Identificador da cobrança (26 a 35 caracteres) | Opcional. Sem ele, não há cobrança para conciliar. |
| valor | Valor recebido | É texto com ponto e duas casas ("110.00"), não número. |
| horario | Quando o banco processou o Pix | Data e hora RFC 3339, em geral com Z (UTC). |
| devolucoes | Devoluções ligadas a esse Pix | É uma lista; cada item tem status. |

## Lendo o aviso com segurança

O código abaixo valida o envelope, percorre todos os Pix (não só o primeiro) e converte o valor para centavos sem passar por número com vírgula, o que evita erros de arredondamento. Ele também descarta repetições do mesmo endToEndId.

```
function lerWebhookPix(corpo, jaProcessados) {
  if (!corpo || !Array.isArray(corpo.pix)) throw new Error('Corpo inesperado: falta a lista "pix"');
  const vistos = jaProcessados || new Set();
  const novos = [];
  for (const p of corpo.pix) {
    if (!/^[a-zA-Z0-9]{32}$/.test(p.endToEndId)) throw new Error('endToEndId inválido');
    if (typeof p.valor !== 'string' || !/^\d{1,10}\.\d{2}$/.test(p.valor)) throw new Error('valor inválido: ' + p.valor);
    if (vistos.has(p.endToEndId)) continue;
    vistos.add(p.endToEndId);
    const [reais, centavos] = p.valor.split('.');
    novos.push({ endToEndId: p.endToEndId, txid: p.txid ?? null, valorCentavos: Number(reais) * 100 + Number(centavos), horarioUtc: p.horario });
  }
  return novos;
}
```

Em produção, o conjunto de identificadores já processados deve ficar em um banco de dados, não na memória, para sobreviver a reinícios. Isso é uma boa prática, não uma regra da especificação.

## Os erros mais comuns

- Valor como número. Se o seu sistema transforma "110.50" em 110.5 e depois compara com texto, a conciliação falha. Mantenha o valor como texto até converter para centavos.
- Ler só pix[0]. Como o banco pode agrupar avisos, ignorar os demais itens perde pagamentos.

- Esquecer o fuso. 2020-09-09T20:15:00.358Z é 17h15 em Brasília. Converta antes de mostrar ao usuário ou de comparar com a data de vencimento.
- Devolução como objeto. A especificação define devolucoes como lista. No exemplo pixWebhook1 do próprio documento, o campo aparece como objeto, uma inconsistência que vale conhecer. Se o seu banco enviar um objeto, aceite os dois formatos no seu código.

- Tratar o aviso como prova de pagamento. O aviso diz que algo aconteceu; para liberar algo de alto valor, confirme também pela consulta de Pix do banco.

## Devoluções: o segundo tipo de aviso

Quando você devolve um Pix, o mesmo endereço recebe um aviso quando a devolução termina. Cada devolução tem id, rtrId, valor, status e um horario com solicitacao e, quando liquidada, liquidacao. Os status possíveis são EM_PROCESSAMENTO, DEVOLVIDO e NAO_REALIZADO. Só os dois últimos são finais e disparam o aviso. Trate NAO_REALIZADO como um alerta para a sua equipe, não como sucesso.

## Como testar sem movimentar dinheiro

Cole o corpo no validador de webhook do Pix (https://meajudaflow.com.br/tools/webhook-pix): ele confere cada campo contra o esquema oficial, mostra os valores e o horário de Brasília e aponta o caminho exato do erro (por exemplo, pix[0].valor). Para montar os seus testes, comece pelos exemplos da especificação e altere um campo por vez para ver o que o seu código faz com valor número, horário local e lista vazia.

## Limites

Este guia segue a versão 2.11.0-rc1 da especificação, que é uma versão candidata. Bancos e provedores podem estar em versões anteriores ou acrescentar campos próprios; consulte a documentação do seu provedor. O que está descrito aqui não substitui o Manual de Padrões para Iniciação do Pix, que também trata da autenticação do serviço (mTLS).

Fontes oficiais:
- API Pix: especificação OpenAPI do Banco Central, versão 2.11.0-rc1 (licença Apache 2.0): https://github.com/bacen/pix-api/blob/master/openapi.yaml
- Pix: documentação e manuais do Banco Central: https://www.bcb.gov.br/estabilidadefinanceira/pix
- IETF RFC 3339: data e hora na internet: https://www.rfc-editor.org/rfc/rfc3339

## Como validar várias chaves de NF-e de uma vez

URL: https://meajudaflow.com.br/guias/como-validar-varias-chaves-de-nfe-de-uma-vez
Atualizado em: 2026-11-09

Quem concilia notas de fornecedores ou prepara uma auditoria raramente tem uma chave só. Dá para conferir a estrutura e o dígito verificador de uma lista inteira em segundos, desde que o resultado volte para a planilha sem perder dígitos.

## Quando a conferência em lote ajuda

Conferir uma chave de acesso na mão é rápido. Conferir 300 não é, e é nesse volume que aparecem os erros: um dígito trocado ao digitar, uma chave cortada ao copiar do PDF, a mesma nota lançada duas vezes. A conferência em lote não diz se a nota existe, mas separa depressa o que está estruturalmente certo do que precisa de atenção.

Alguns casos em que ela poupa tempo:

- Lista de notas recebidas em um mês, antes de lançar no sistema.
- Chaves coletadas de e-mails e PDFs, com formatos misturados (com espaço, com ponto, coladas).
- Revisão de uma planilha herdada, em que não se sabe quais chaves foram digitadas à mão.
- Procura de duplicidades antes de pagar fornecedores.

## Como montar a lista

Use uma chave por linha. A ferramenta aceita espaços, pontos, traços e letras minúsculas, e ignora as linhas em branco. Por isso você pode colar direto da planilha, do e-mail ou de uma exportação do sistema, sem limpar antes. O limite é de 2.000 linhas por vez.

## Lendo o resultado

Cada linha vira um registro com o resultado da conferência. Quando algo não bate, o motivo aparece na própria linha, sem interromper as demais.

| Alerta | O que significa | O que fazer |
| --- | --- | --- |
| Chave com tamanho diferente de 44 | Falta ou sobra caractere, em geral por cópia incompleta | Copie de novo da fonte, de preferência do XML |
| Dígito verificador não confere | Algum dos 43 primeiros caracteres foi digitado errado, ou o último está errado | Releia a chave original |
| Código de UF inexistente ou mês inválido | A parte inicial não segue a estrutura da chave | Provável erro de digitação ou campo errado |
| CNPJ do emitente com dígitos que não conferem | O bloco do emitente não passa na validação do CNPJ | Confirme o emitente na nota |
| Chave repetida | A mesma chave já apareceu em uma linha anterior | Veja se a nota foi lançada em duplicidade |

Uma linha que "confere" quer dizer que a estrutura e o dígito estão consistentes. Não quer dizer que a nota existe, está autorizada ou foi cancelada. Essa informação só a SEFAZ confirma, pelo portal nacional da NF-e ou pelo seu sistema fiscal.

## O CNPJ alfanumérico na chave

Com o CNPJ alfanumérico, o campo do emitente dentro da chave também pode ter letras maiúsculas e números. A conferência em lote já aceita essas chaves e recalcula o dígito com o mesmo método do CNPJ alfanumérico, em que cada caractere vale o seu código menos 48. Se a sua lista tem chaves de fornecedores com CNPJ novo, elas não precisam de tratamento especial.

## Levando o resultado para o Excel

O botão "Copiar resultado em CSV" gera um texto com colunas separadas por ponto e vírgula: linha, chave, confere, UF, emissão, emitente, modelo, série, número e alertas. Cole em um arquivo de texto salvo com a extensão .csv e abra no Excel.

Há um cuidado importante com a chave. O Excel guarda números com no máximo 15 dígitos de precisão, e a chave tem 44. Se ela for interpretada como número, o Excel a transforma em notação científica e perde os dígitos finais, e a chave fica irrecuperável. Para evitar isso, o CSV mostra a chave em grupos de quatro caracteres separados por espaço (por exemplo, 3526 0111 2223 ...), o que faz o Excel tratá-la como texto. Se você precisar da chave sem espaços, use a função de substituir espaços em uma coluna ao lado.

Mesmo assim, se for importar o CSV por outro caminho (como "De texto/CSV" em Dados), marque a coluna da chave como Texto na tela de importação.

## Privacidade

A lista é lida no seu navegador. Nada é enviado a servidor nenhum, e a ferramenta não consulta a SEFAZ. Chaves de notas fiscais identificam empresas e valores, então essa característica importa quando a lista vem de um cliente.

## Um roteiro simples de conciliação

- Cole a lista e leia o resumo: quantas conferem.
- Resolva primeiro as de tamanho errado e dígito errado, que costumam ser digitação.
- Veja as repetidas antes de pagar ou lançar.
- Copie o CSV e junte ao seu controle de pagamentos pela chave.
- Para as notas que importam (valor alto, fornecedor novo), consulte a situação na SEFAZ.

A ferramenta de decodificação de chave de NF-e (https://meajudaflow.com.br/tools/nfe) faz tudo isso, e o guia Como conferir a chave de acesso da NF-e (https://meajudaflow.com.br/guias/como-conferir-chave-de-acesso-da-nfe) explica o cálculo do dígito verificador em detalhe.

Fontes oficiais:
- Manual de Orientação ao Contribuinte (MOC) 7.0, Visão Geral, item 2.2.6 (Portal Nacional da NF-e): https://www.nfe.fazenda.gov.br/portal/exibirArquivo.aspx?conteudo=LrBx7WT9PuA=
- Especificações e limites do Excel: precisão de número de 15 dígitos (Microsoft): https://support.microsoft.com/pt-br/office/especifica%C3%A7%C3%B5es-e-limites-do-excel-1672b34d-7043-467e-8e27-269d656771c3
- Receita Federal: perguntas e respostas sobre o CNPJ alfanumérico: https://www.gov.br/receitafederal/pt-br/centrais-de-conteudo/publicacoes/perguntas-e-respostas/cnpj/cnpj-alfanumerico.pdf

# Referência de funções do Power Automate

## formatDateTime (Power Automate)

URL: https://meajudaflow.com.br/referencia/power-automate/formatdatetime
Uso: formatDateTime(data, [formato], [cultura])

Converte uma data em texto no formato que você escolher. É a função mais usada para mostrar datas ao usuário e para montar nomes de arquivo, e a que mais dá erro por causa de maiúsculas e minúsculas.

Exemplos executados de verdade no Power Automate (2026-11-02):
- formatDateTime('2026-11-02T08:05:09Z', 'dd/MM/yyyy HH:mm:ss') => 02/11/2026 08:05:09
- formatDateTime('2026-11-02T08:05:09Z', 'mm') => 05 (mm minúsculo = minutos)
- formatDateTime('2026-11-02T08:05:09Z', 'MM') => 11 (MM maiúsculo = mês)
- formatDateTime('2026-03-07T15:04:05.678Z', 'dddd, d ''de'' MMMM ''de'' yyyy', 'pt-BR') => sábado, 7 de março de 2026 (o texto fixo usa aspas dobradas dentro da expressão)
- formatDateTime('2026-03-07T15:04:05.678Z', 'MMMM', 'en-US') => March
- formatDateTime('2026-03-07T15:04:05.678Z', 'yyyyMMdd_HHmmss') => 20260307_150405 (bom para nomes de arquivo)
- formatDateTime('2026-03-07T15:04:05.678Z', 'd', 'pt-BR') => 07/03/2026 ('d' sozinho é um formato padrão)
- formatDateTime('2026-11-02T08:05:09Z') => 2026-11-02T08:05:09.0000000Z (sem formato: ISO completo)

Pegadinhas:
- MM é mês, mm é minuto. Trocar as maiúsculas é o erro número um: o fluxo não falha, grava o valor errado.
- HH é 24 horas e hh é 12 horas. Com hh, acrescente tt para AM/PM.
- Uma letra só é formato padrão. 'H' falha com "format parameter 'H' is not supported"; para o formato personalizado escreva '%H'.
- Aspas simples dentro do formato se dobram. O formato dd 'de' MMMM vira 'dd ''de'' MMMM' na expressão.
- Sem cultura, vale en-US (padrão documentado pela Microsoft): os nomes de mês e dia saem em inglês.

Quando usar: Use formatDateTime sempre que uma data for mostrada a alguém ou gravada como texto: no corpo de um e-mail, no nome de um arquivo (yyyyMMdd_HHmmss), no título de uma aprovação ou em uma coluna de texto do SharePoint. Não use para fazer contas: formate só no final, depois de somar dias, converter o fuso ou comparar. Mantenha as datas como datas (ISO) enquanto o fluxo calcula e só transforme em texto na última ação. Isso evita o erro clássico de comparar "02/11/2026" com "15/10/2026" como se fossem textos: em ordem alfabética o primeiro viria antes, mesmo sendo uma data posterior.

Fontes oficiais:
- Referência de funções de expressão do Power Automate e Logic Apps (Microsoft Learn): formatDateTime: https://learn.microsoft.com/azure/logic-apps/workflow-definition-language-functions-reference
- Cadeias de formato de data e hora personalizadas (Microsoft Learn): https://learn.microsoft.com/dotnet/standard/base-types/custom-date-and-time-format-strings
- Cadeias de formato de data e hora padrão (Microsoft Learn): https://learn.microsoft.com/dotnet/standard/base-types/standard-date-and-time-format-strings

## convertTimeZone (Power Automate)

URL: https://meajudaflow.com.br/referencia/power-automate/converttimezone
Uso: convertTimeZone(data, fusoOrigem, fusoDestino, [formato])

Converte uma data de um fuso horário para outro. Os fusos são identificados pelo nome do Windows (por exemplo, E. South America Standard Time para Brasília), não pelo nome usado em outras linguagens (America/Sao_Paulo).

Exemplos executados de verdade no Power Automate (2026-11-02):
- convertTimeZone('2026-11-02T11:30:00Z', 'UTC', 'E. South America Standard Time', 'dd/MM/yyyy HH:mm') => 02/11/2026 08:30
- convertTimeZone('2026-07-15T12:00:00Z', 'UTC', 'E. South America Standard Time', 'HH:mm') => 09:00 (Brasília, UTC-3)
- convertTimeZone('2026-07-15T12:00:00Z', 'UTC', 'Eastern Standard Time', 'HH:mm') => 08:00 (Nova York em julho (horário de verão))
- convertTimeZone('2026-01-15T12:00:00Z', 'UTC', 'Eastern Standard Time', 'HH:mm') => 07:00 (Nova York em janeiro)
- convertTimeZone('2026-07-15T12:00:00Z', 'UTC', 'GMT Standard Time', 'HH:mm') => 13:00 (Londres em julho)
- convertTimeZone('2026-07-15T12:00:00Z', 'UTC', 'India Standard Time', 'HH:mm') => 17:30
- convertTimeZone('2026-07-15T12:00:00Z', 'UTC', 'SA Western Standard Time', 'HH:mm') => 08:00 (Manaus, UTC-4)
- convertTimeZone('2026-07-15T12:00:00Z', 'UTC', 'E. South America Standard Time') => 2026-07-15T09:00:00.0000000 (sem formato: ISO sem o Z)

Pegadinhas:
- Nome do Windows, não o da IANA. Um nome errado dá erro na execução.
- O resultado sem formato não traz o Z: 2026-07-15T09:00:00.0000000 já é horário de Brasília, e não UTC. Não o reconverta como se fosse UTC.
- O horário de verão é respeitado: Nova York está 1 hora mais perto de Brasília em julho do que em janeiro. Converta sempre com a data real.
- O Brasil tem 4 fusos (Fernando de Noronha, Brasília, Manaus/Cuiabá e Rio Branco), com nomes diferentes: veja o conversor abaixo.

Quando usar: Use convertTimeZone quando o fluxo precisa mostrar ou comparar horários no fuso de pessoas: avisos com horário de reunião, prazos no horário de Brasília, relatórios para equipes em outros países. Guarde sempre o instante original em UTC (é o que utcNow() e a maioria dos conectores devolvem) e converta só na hora de exibir. Assim, uma mudança de horário de verão ou uma equipe em outro país não obriga a reescrever o fluxo. Para um prazo "até as 18:00 de Brasília", converta o horário atual para Brasília e compare com 18:00, em vez de somar ou subtrair três horas na mão.

Fontes oficiais:
- Referência de funções de expressão do Power Automate e Logic Apps (Microsoft Learn): convertTimeZone: https://learn.microsoft.com/azure/logic-apps/workflow-definition-language-functions-reference
- Fusos horários padrão do Windows (Microsoft Learn): https://learn.microsoft.com/windows-hardware/manufacture/desktop/default-time-zones

## parseDateTime (Power Automate)

URL: https://meajudaflow.com.br/referencia/power-automate/parsedatetime
Uso: parseDateTime(texto, [cultura], [formato])

Transforma um texto em data. Serve para ler datas digitadas por pessoas, como 03/04/2026, antes de somar dias, comparar ou formatar. O parâmetro de cultura decide qual número é o dia e qual é o mês.

Exemplos executados de verdade no Power Automate (2026-11-02):
- parseDateTime('03/04/2026', 'pt-BR') => 2026-04-03T00:00:00.0000000 (3 de abril)
- parseDateTime('03/04/2026', 'en-US') => 2026-03-04T00:00:00.0000000 (4 de março)
- formatDateTime(parseDateTime('03/04/2026', 'pt-BR'), 'dd/MM/yyyy') => 03/04/2026 (ida e volta)

Pegadinhas:
- Sem cultura, o dia e o mês podem trocar. Com 'en-US', 03/04/2026 é 4 de março; com 'pt-BR', é 3 de abril. Informe sempre a cultura.
- O resultado não traz fuso (não termina em Z). Combine com convertTimeZone se o fuso importar.
- O texto precisa estar limpo. Espaços, barras diferentes ou ano de dois dígitos podem dar erro: valide antes.

Quando usar: Use parseDateTime sempre que a data chegar como texto digitado por pessoas ou exportado de planilhas: campos de formulário, colunas de texto, arquivos CSV. É o primeiro passo antes de qualquer conta com datas, porque addDays, formatDateTime e as comparações precisam de uma data de verdade, não de um texto parecido com data. O padrão seguro é converter logo que o dado entra no fluxo, guardar o resultado em uma ação Compor com nome claro (por exemplo, Data_vencimento) e usar essa ação no resto do fluxo. Informe sempre a cultura ('pt-BR'): é o que impede que o dia e o mês troquem de lugar em silêncio.

Fontes oficiais:
- Referência de funções de expressão do Power Automate e Logic Apps (Microsoft Learn): parseDateTime: https://learn.microsoft.com/azure/logic-apps/workflow-definition-language-functions-reference

## formatNumber (Power Automate)

URL: https://meajudaflow.com.br/referencia/power-automate/formatnumber
Uso: formatNumber(número, formato, [cultura])

Formata um número como texto: moeda, milhar, casas decimais, zeros à esquerda, percentual. Com a cultura pt-BR, usa o ponto como separador de milhar e a vírgula como decimal. O resultado é texto, não número.

Exemplos executados de verdade no Power Automate (2026-11-02):
- formatNumber(float(replace(replace('1.234,56', '.', ''), ',', '.')), 'N2', 'pt-BR') => 1.234,56 (ida e volta do padrão brasileiro)
- formatNumber(div(float(123456789), 100), 'N2', 'pt-BR') => 1.234.567,89
- formatNumber(1234.5, 'N2', 'en-US') => 1,234.50
- formatNumber(1234.5, 'C2', 'pt-BR') => R$ 1.234,50
- formatNumber(1234.5678, '#,##0.00', 'pt-BR') => 1.234,57
- formatNumber(0.256, 'P1', 'pt-BR') => 25,6%
- formatNumber(7, '000') => 007 (zeros à esquerda)
- formatNumber(-1234.5, 'N2', 'pt-BR') => -1.234,50
- formatNumber(3.14159, 'N2') => 3.14 (sem cultura, o ponto é decimal)
- formatNumber(2.5, 'F0') => 2 (arredondamento de metade)
- formatNumber(3.5, 'F0') => 4
- formatNumber(0.125, '0.00') => 0.13
- formatNumber(2.675, 'F2') => 2.67

Pegadinhas:
- Devolve texto. Para continuar calculando, converta de volta (e cuidado com a vírgula: veja int e float).
- Uma letra só é formato padrão. O formato '0' (um zero) funciona como formato personalizado e arredonda o meio para cima: formatNumber(2.5, '0') devolve 3, enquanto 'F0' devolve 2 (executado em 09/11/2026). Escolha 'F0', '0', '0.00' ou '000' conforme o arredondamento e o preenchimento que você quer.
- O arredondamento de metades não é uniforme. F0 de 2,5 dá 2 e de 3,5 dá 4, enquanto '0.00' de 0,125 dá 0,13 e F2 de 2,675 dá 2,67. Para dinheiro, calcule em centavos: veja o guia de parcelas.
- Sem cultura, o separador decimal é o ponto.

Quando usar: Use formatNumber para apresentar valores: moeda em e-mails e aprovações ('C2' com pt-BR dá R$ 1.234,50), percentuais em relatórios e códigos com zeros à esquerda ('00000'). Faça as contas antes, com números, e formate só no final, porque o resultado é texto e não entra mais em add ou mul sem conversão. Para dinheiro, evite depender do arredondamento do formato: calcule em centavos inteiros, converta para reais só na apresentação e, se precisar de duas casas, formate um valor que já tenha exatamente duas casas.

Fontes oficiais:
- Referência de funções de expressão do Power Automate e Logic Apps (Microsoft Learn): formatNumber: https://learn.microsoft.com/azure/logic-apps/workflow-definition-language-functions-reference
- Cadeias de formato numérico padrão (Microsoft Learn): https://learn.microsoft.com/dotnet/standard/base-types/standard-numeric-format-strings
- Cadeias de formato numérico personalizadas (Microsoft Learn): https://learn.microsoft.com/dotnet/standard/base-types/custom-numeric-format-strings

## int, float e string (Power Automate)

URL: https://meajudaflow.com.br/referencia/power-automate/int-float
Uso: int(valor)   float(valor, [cultura])   string(valor)

Convertem entre texto e número. Parecem simples, mas têm três armadilhas que já derrubaram muito fluxo financeiro: int não aceita decimais, float descarta a vírgula sem avisar e float não entende o formato brasileiro com ponto de milhar.

Exemplos executados de verdade no Power Automate (2026-11-02):
- int('42') => 42
- float('1.5') => 1.5
- float('19.99') => 19.99
- float('1,5') => 15 (a vírgula é descartada, sem erro)
- float('1000,50') => 100050 (idem: 1000,50 vira 100050)
- float(replace(replace('1.234,56', '.', ''), ',', '.')) => 1234.56 (limpeza para o padrão brasileiro)
- float(replace(replace('-1.234,56', '.', ''), ',', '.')) => -1234.56
- float(replace(replace('1000.50', '.', ''), ',', '.')) => 100050 (a limpeza estraga texto com ponto decimal)
- int(formatNumber(float('3.14'), 'F0')) => 3
- string(42) => 42 (devolve o texto 42)
- bool('true') => true

Pegadinhas:
- int('3.14') e int(float('3.14')) dão erro ("The value cannot be converted to the target type"). Para obter um inteiro, arredonde antes com formatNumber e 'F0', ou trabalhe sempre com inteiros.
- float('1,5') devolve 15, não 1,5, e float('1000,50') devolve 100050. A vírgula é descartada, e o fluxo segue com um valor cem vezes maior.
- float('1.234,56') dá erro (ponto de milhar mais vírgula decimal). Informe a cultura, como float('1.234,56', 'pt-BR'), ou limpe o texto antes.
- A limpeza replace(replace(x, '.', ''), ',', '.') só vale para texto no padrão brasileiro. Em 1000.50 ela remove o ponto decimal e devolve 100050. Decida o formato na origem.
- Textos com "R$" ou espaços precisam de outro replace antes (testado com R$ 1.234,56).
- Para texto no padrão brasileiro, float aceita uma cultura: float('1.234,56', 'pt-BR') devolve 1234.56 (executado em 09/11/2026). Com 'en-US' o mesmo texto dá erro. É mais simples que a limpeza com replace quando todo o texto vem no padrão brasileiro.

Quando usar: Use int e float quando um valor chega como texto (campos de formulário, colunas de texto, anexos) e você precisa calcular com ele. O cuidado é sempre o mesmo: descubra em que formato o texto vem. Se vem como 1234.56, float serve direto; se vem como 1.234,56 ou 1234,56 (padrão brasileiro), é preciso limpar antes, porque a conversão direta ou falha ou, pior, devolve um valor cem vezes maior sem nenhum aviso. Quando o resultado precisa ser inteiro, evite int sobre decimais e trabalhe desde o início em centavos. Valide o resultado (maior que zero, dentro de uma faixa esperada) antes de gravar em qualquer sistema.

Fontes oficiais:
- Referência de funções de expressão do Power Automate e Logic Apps (Microsoft Learn): int, float e string: https://learn.microsoft.com/azure/logic-apps/workflow-definition-language-functions-reference

## div, mod, mul e add (Power Automate)

URL: https://meajudaflow.com.br/referencia/power-automate/div-mod
Uso: div(a, b)   mod(a, b)   mul(a, b)   add(a, b)   sub(a, b)

As quatro operações do Power Automate se comportam como as de uma linguagem de programação, não como as de uma calculadora: dois inteiros dão um inteiro, e decimais carregam resíduos de ponto flutuante. Entender isso evita divergências de centavos.

Exemplos executados de verdade no Power Automate (2026-11-02):
- div(75, 200) => 0 (dois inteiros: trunca)
- div(float(75), float(200)) => 0.375
- div(10, 4) => 2
- div(float(10), 4) => 2.5
- div(100000, 3) => 33333
- mod(100000, 3) => 1 (o resto)
- mod(10, 3) => 1
- mod(-5, 2) => -1 (o sinal segue o dividendo)
- mul(19.99, 100) => 1998.9999999999998 (resíduo de ponto flutuante)
- add(0.1, 0.2) => 0.30000000000000004
- mul(0.1, 3) => 0.30000000000000004
- sub(5, 2) => 3

Pegadinhas:
- Divisão de inteiros trunca. div(75, 200) é 0. Converta um dos lados com float quando quiser decimal.
- Decimais carregam resíduos: mul(19.99, 100) não dá 1999, e add(0.1, 0.2) não dá 0,3. Para dinheiro, use centavos inteiros.
- Dividir por zero dá erro. Valide o divisor antes.
- Não existem round, floor nem ceil, e o pow falhou no teste. A referência da Microsoft lista o pow, mas, ao executar no Power Automate (02/11/2026), a resposta foi "The template function 'pow' is not defined". Confira no seu ambiente antes de depender dele.

Quando usar: Use div e mod sempre que precisar de uma divisão exata com resto, como em parcelas, lotes e paginação: div(a, b) dá o quociente inteiro e mod(a, b) dá o que sobra. O padrão para dinheiro é converter o valor para centavos inteiros, dividir com div, ficar com o resto em mod e somá-lo a uma das parcelas, para que o total bata exatamente. Use mul e add sobre decimais só quando o resíduo for aceitável, por exemplo em estatísticas; em valores financeiros, prefira sempre inteiros. Antes de dividir, valide que o divisor não é zero, porque a divisão por zero derruba a ação.

Fontes oficiais:
- Referência de funções de expressão do Power Automate e Logic Apps (Microsoft Learn): div, mod, mul, add e sub: https://learn.microsoft.com/azure/logic-apps/workflow-definition-language-functions-reference

## addDays, addToTime e datas relativas (Power Automate)

URL: https://meajudaflow.com.br/referencia/power-automate/adddays-addtotime
Uso: addDays(data, dias, [formato])   addToTime(data, quantidade, unidade, [formato])

Somam ou subtraem tempo de uma data. addDays é a mais usada para vencimentos; addToTime aceita outras unidades (semana, mês, ano) e respeita o calendário.

Exemplos executados de verdade no Power Automate (2026-11-02):
- addDays('2026-11-02T00:00:00Z', 7, 'yyyy-MM-dd') => 2026-11-09
- addDays('2026-11-02T00:00:00Z', -30, 'yyyy-MM-dd') => 2026-10-03 (valor negativo subtrai)
- addToTime('2026-11-02T00:00:00Z', 2, 'Week', 'yyyy-MM-dd') => 2026-11-16
- addToTime('2026-01-31T00:00:00Z', 1, 'Month', 'yyyy-MM-dd') => 2026-02-28 (31/01 + 1 mês cai no último dia de fevereiro)
- subtractFromTime('2026-11-02T00:00:00Z', 1, 'Day', 'yyyy-MM-dd') => 2026-11-01
- addHours('2026-11-02T00:00:00Z', 5, 'HH:mm') => 05:00
- startOfMonth('2026-11-15T10:00:00Z', 'yyyy-MM-dd') => 2026-11-01
- startOfDay('2026-11-02T15:30:00Z', 'HH:mm') => 00:00
- dayOfWeek('2026-11-02T00:00:00Z') => 1 (0 = domingo, 1 = segunda)
- dayOfMonth('2026-11-02T00:00:00Z') => 2
- dateDifference('2026-11-02T00:00:00Z', '2026-11-05T12:00:00Z') => 3.12:00:00 (3 dias e 12 horas)

Pegadinhas:
- Parcelas de 30 em 30 dias derivam do calendário: a partir de 02/11/2026, as datas são 2026-12-02, 2027-01-01 e 2027-01-31. Para o mesmo dia de cada mês, use addToTime com 'Month'.
- Fim de mês: 31/01 + 1 mês devolve 28/02 (e não 03/03).
- Sem o formato, o resultado é um ISO longo. Informe 'yyyy-MM-dd' quando precisar só da data.
- Tudo em UTC. Somar dias a uma data de Brasília exige converter o fuso antes.

Quando usar: Use addDays para prazos simples (vencimento em 7 dias, lembrete 3 dias antes com valor negativo) e addToTime quando a unidade for semana, mês ou ano e o calendário importar: o mesmo dia do mês seguinte, o fim de um trimestre. Use startOfMonth e startOfDay para zerar a parte que não interessa antes de comparar, e dayOfWeek para decidir o que fazer em fins de semana (0 é domingo e 6 é sábado). Para saber quanto tempo passou entre dois instantes, use dateDifference, que devolve dias, horas, minutos e segundos em um único texto. Lembre que todos trabalham em UTC, a menos que você converta o fuso.

Fontes oficiais:
- Referência de funções de expressão do Power Automate e Logic Apps (Microsoft Learn): addDays, addToTime, dateDifference e dayOfWeek: https://learn.microsoft.com/azure/logic-apps/workflow-definition-language-functions-reference

## concat, join e split (Power Automate)

URL: https://meajudaflow.com.br/referencia/power-automate/concat-join-split
Uso: concat(texto1, texto2, …)   join(lista, separador)   split(texto, separador)

concat junta textos, join junta os itens de uma lista em um texto, e split faz o caminho inverso, dividindo um texto em uma lista. Juntas, resolvem a maior parte da montagem de mensagens e do tratamento de respostas de formulário.

Exemplos executados de verdade no Power Automate (2026-11-02):
- concat('Olá, ', outputs('Dados')?['nome']) => Olá, Ana (com nome = Ana)
- concat('a', 1) => a1 (números viram texto)
- concat('a', outputs('Dados')?['apelido'], 'b') => ab (com apelido nulo: nulo vira nada)
- join(createArray('a','b','c'), ', ') => a, b, c
- join(createArray(1,2,3), '-') => 1-2-3
- split('a;b;c', ';') => ["a","b","c"]
- split('abc', ';') => ["abc"] (sem o separador: lista de 1 item)
- length(split('a;b;c', ';')) => 3 (conta os itens)
- join(json(outputs('Dados')?['multiTexto']), ', ') => Cimento, Areia (resposta do Forms em texto de lista)
- string(outputs('Dados')?['apelido']) =>  (string de nulo é texto vazio)

Pegadinhas:
- Nulo vira nada, não a palavra "null". Útil, mas esconde campos faltando: valide antes de montar mensagens importantes.
- join exige uma lista. Se a resposta chega como texto no formato de lista (como no Forms), converta com json() antes.
- split sempre devolve uma lista, mesmo sem o separador. Use first() para pegar o primeiro item.
- Quebra de linha em e-mail HTML não vem do concat: use <br> no texto.

Quando usar: Use concat para montar mensagens, títulos de aprovação e caminhos de arquivo; join para transformar uma lista em um texto legível (as opções marcadas em um formulário, os nomes de vários responsáveis); e split para o caminho inverso, quando um campo guarda vários valores separados por ponto e vírgula. Combine com length para contar itens, first e last para pegar pontas e trim para limpar espaços de cada item. Em mensagens importantes, não deixe campos nulos passarem em silêncio: como o nulo vira nada, uma frase como "Prezado ," sai sem aviso. Valide os campos críticos antes de montar o texto final.

Fontes oficiais:
- Referência de funções de expressão do Power Automate e Logic Apps (Microsoft Learn): concat, join, split e json: https://learn.microsoft.com/azure/logic-apps/workflow-definition-language-functions-reference

## coalesce e empty (Power Automate)

URL: https://meajudaflow.com.br/referencia/power-automate/coalesce-empty
Uso: coalesce(valor1, valor2, …)   empty(valor)

coalesce devolve o primeiro valor que não é nulo; empty diz se um texto, lista ou objeto está vazio. Os dois são a base de qualquer tratamento de campo opcional, e a diferença entre "nulo" e "vazio" é onde mora a maioria dos erros.

Exemplos executados de verdade no Power Automate (2026-11-02):
- coalesce(outputs('Dados')?['apelido'], outputs('Dados')?['nome'], 'Cliente') => Ana (apelido nulo: usa o nome)
- coalesce('', 'x') =>  (texto vazio NÃO é nulo: coalesce devolve '')
- coalesce(outputs('Dados')?['apelido'], outputs('Dados')?['naoExiste']) => null (tudo nulo: devolve nulo)
- empty(outputs('Dados')?['apelido']) => true (nulo conta como vazio)
- if(empty(outputs('Dados')?['obs']), 'Sem observação', outputs('Dados')?['obs']) => Sem observação (com obs = texto vazio)
- empty('  ') => false (só espaços NÃO é vazio)
- empty(json('[]')) => true (lista vazia)
- outputs('Dados')?['pedido']?['naoExiste']?['x'] => null (caminho que não existe devolve nulo)

Pegadinhas:
- coalesce não pula texto vazio. Se o campo pode chegar como '', combine com empty: if(empty(x), y, x).
- Só espaços não é vazio. Use trim() antes de empty().
- Nulo e vazio são coisas diferentes, mas empty trata os dois como vazio.
- createArray() sem itens é inválido. Para uma lista vazia, use json('[]').

Quando usar: Use coalesce para valores padrão encadeados (apelido, depois nome, depois "Cliente") e empty dentro de um if para decidir o que fazer com campos opcionais. O padrão mais seguro para um campo que pode chegar nulo ou como texto vazio é if(empty(x), padrão, x), que trata os dois casos. Se o campo ainda puder ter só espaços, passe o texto por trim antes, desde que ele nunca seja nulo. Use o acesso seguro com ? em toda leitura de campo que possa não existir, para o fluxo receber nulo em vez de falhar. E teste sempre os três casos: campo preenchido, campo vazio e campo ausente.

Fontes oficiais:
- Referência de funções de expressão do Power Automate e Logic Apps (Microsoft Learn): coalesce, empty e createArray: https://learn.microsoft.com/azure/logic-apps/workflow-definition-language-functions-reference
- Use expressões em condições para verificar vários valores (Microsoft Learn): https://learn.microsoft.com/power-automate/use-expressions-in-conditions

## equals, contains, startsWith e indexOf (Power Automate)

URL: https://meajudaflow.com.br/referencia/power-automate/comparacoes
Uso: equals(a, b)   contains(coleção, valor)   startsWith(texto, prefixo)   endsWith(texto, sufixo)   indexOf(texto, busca)

Cada função de comparação tem a sua própria regra de maiúsculas e minúsculas, e isso muda o resultado de condições que parecem idênticas. A tabela abaixo foi montada executando cada uma no Power Automate.

Exemplos executados de verdade no Power Automate (2026-11-02):
- equals('Ana', 'ana') => false (diferencia)
- contains('abc', 'B') => false (diferencia)
- startsWith('Cimento 50', 'cim') => true (NÃO diferencia)
- endsWith('x.CSV', '.csv') => true (NÃO diferencia)
- indexOf('ABC', 'b') => 1 (NÃO diferencia)
- indexOf('abc', 'z') => -1 (não achou: -1)
- equals(1, '1') => false (número e texto são diferentes)
- contains(outputs('Dados')?['multiTexto'], 'Cim') => true (em TEXTO, procura um trecho)
- contains(outputs('Dados')?['multiArray'], 'Cim') => false (em LISTA, só o item inteiro)
- contains(outputs('Dados')?['pedido'], 'cliente') => true (em objeto, procura a chave)
- contains(createArray(1,2,3), 2) => true
- greater('b', 'a') => true

Pegadinhas:
- Regra de bolso: equals e contains diferenciam maiúsculas; startsWith, endsWith e indexOf ignoram. Para igualar, normalize os dois lados com toLower().
- contains em texto procura trecho: "Cimento Branco" também contém "Cimento". Em lista, exige o item inteiro. Confira se a resposta chegou como texto ou como lista.
- equals(1, '1') é falso na execução real. Converta os tipos antes de comparar. (A documentação mostra equals(true, 1) como verdadeiro, então não conte com a mesma regra para todos os pares de tipos.)
- Filtre anexos com endsWith(nome, '.csv') sem se preocupar com .CSV.

Quando usar: Antes de escrever uma condição com texto, decida duas coisas: a comparação deve diferenciar maiúsculas de minúsculas, e o valor é um texto, uma lista ou um objeto? Para comparações tolerantes, normalize os dois lados com toLower() e compare com equals, em vez de contar com a regra de cada função. Use startsWith e endsWith para prefixos e extensões de arquivo (.csv), contains para ver se um item existe em uma lista e indexOf para saber a posição de um trecho. Se a resposta de um formulário pode chegar como texto de lista, trate-a (ou converta com json()) antes de usar contains, para não aceitar trechos parciais.

Fontes oficiais:
- Referência de funções de expressão do Power Automate e Logic Apps (Microsoft Learn): equals, contains, startsWith, endsWith e indexOf: https://learn.microsoft.com/azure/logic-apps/workflow-definition-language-functions-reference
- Use expressões em condições para verificar vários valores (Microsoft Learn): https://learn.microsoft.com/power-automate/use-expressions-in-conditions

## replace, substring, trim e toUpper (Power Automate)

URL: https://meajudaflow.com.br/referencia/power-automate/replace-substring-trim
Uso: replace(texto, antigo, novo)   substring(texto, início, [comprimento])   trim(texto)

As funções de texto do dia a dia: trocar um trecho, extrair uma parte, limpar espaços e ajustar maiúsculas. Todas trabalham com acentos sem problema; as pegadinhas estão nas posições (que começam em zero) e em quando a troca diferencia maiúsculas.

Exemplos executados de verdade no Power Automate (2026-11-02):
- replace('Ana ANA', 'ana', 'x') => Ana ANA (nada mudou: diferencia maiúsculas)
- replace('a-b-c', '-', '') => abc (trocar por vazio remove)
- substring('abcdef', 0, 3) => abc (posição 0, 3 caracteres)
- substring('abcdef', 2) => cdef (até o fim)
- trim('  x  ') => x
- trim('  a  b  ') => a  b (só as pontas)
- toUpper('ação') => AÇÃO
- toLower('AÇÃO') => ação
- length('Olá') => 3 (conta caracteres, não bytes)
- take('abcdef', 3) => abc

Pegadinhas:
- replace diferencia maiúsculas. Para trocar sem se importar com a caixa, passe o texto por toLower() antes (e aceite que o resultado fica em minúsculas).
- As posições começam em zero. substring('abcdef', 0, 3) pega as três primeiras letras.
- trim não mexe no meio do texto (' a b ' vira 'a b').
- substring além do tamanho do texto dá erro. Confira com length().

Quando usar: Use replace para limpar dados vindos de fora: tirar pontos e vírgulas de números, remover o "R$", trocar separadores. Encadeie vários replace, do mais específico para o mais geral. Use substring com length para extrair partes de códigos de tamanho fixo (os quatro primeiros caracteres de um código, o ano de um identificador) e trim em todo texto digitado por pessoas antes de comparar ou gravar, porque espaços nas pontas fazem textos iguais parecerem diferentes. Para maiúsculas e minúsculas consistentes em chaves e comparações, padronize com toLower ou toUpper logo na entrada do dado.

Fontes oficiais:
- Referência de funções de expressão do Power Automate e Logic Apps (Microsoft Learn): replace, substring, trim e length: https://learn.microsoft.com/azure/logic-apps/workflow-definition-language-functions-reference

## base64, base64ToString e uriComponent (Power Automate)

URL: https://meajudaflow.com.br/referencia/power-automate/base64-uri
Uso: base64(texto)   base64ToString(base64)   uriComponent(texto)

Convertem texto para Base64 (e de volta) e codificam textos para uso em URLs. Aparecem sempre que um anexo de e-mail ou o conteúdo de um arquivo passa pelo fluxo, onde o conteúdo chega em Base64.

Exemplos executados de verdade no Power Automate (2026-11-02):
- base64('Olá') => T2zDoQ==
- base64ToString('T2zDoQ==') => Olá (UTF-8)
- base64ToString('T2zh') => Ol� (mesmo 'Olá', mas salvo em Windows-1252: quebra)
- base64('a?b>') => YT9iPg== (Base64 padrão (com + e /), não URL-safe)
- base64ToString(first(body('Filtrar_anexos'))?['contentBytes']) => nome;valor
Ana;1,5 (conteúdo de um anexo CSV)
- uriComponent('a b&c') => a%20b%26c
- decodeUriComponent('a%20b%26c') => a b&c
- uriComponent('ação') => a%C3%A7%C3%A3o (acentos em UTF-8)

Pegadinhas:
- base64ToString assume UTF-8. Um arquivo em Windows-1252 (comum em CSV do Excel antigo) volta com símbolos no lugar de acentos. Salve em UTF-8 na origem.
- O Base64 gerado é o padrão, com +, / e =. Tokens em Base64URL (JWT) usam - e _ e precisam de conversão.
- Base64 não é criptografia. Qualquer pessoa decodifica; nunca use para esconder senhas.
- Parâmetros em URL: use uriComponent para textos com espaço, &, acentos ou barras.

Quando usar: Você encontra Base64 sempre que um arquivo passa pelo fluxo como conteúdo: anexos de e-mail (contentBytes), arquivos do OneDrive e do SharePoint em ações que devolvem o conteúdo, e cabeçalhos de autenticação básica. Use base64ToString para ler arquivos de texto (como CSV) e base64 para montar o conteúdo ao enviar. Se os acentos saírem trocados, o problema quase nunca é o Base64: é a codificação do arquivo de origem, que não estava em UTF-8. Use uriComponent em qualquer valor que entre em uma URL, como parâmetros de consulta com espaços, acentos ou o caractere &, para evitar requisições quebradas.

Fontes oficiais:
- Referência de funções de expressão do Power Automate e Logic Apps (Microsoft Learn): base64, base64ToString e uriComponent: https://learn.microsoft.com/azure/logic-apps/workflow-definition-language-functions-reference

## range, first, last, take e skip (Power Automate)

URL: https://meajudaflow.com.br/referencia/power-automate/range-first-take
Uso: range(início, quantidade)   first(lista)   last(lista)   take(lista, n)   skip(lista, n)

Funções para criar e fatiar listas. range é a chave dos loops de repetição "N vezes" (como o de parcelas), e first, last, take e skip pegam partes de listas; first, last e take também funcionam com textos, mas skip só aceita lista, segundo a documentação da Microsoft.

Exemplos executados de verdade no Power Automate (2026-11-02):
- range(1, 3) => [1,2,3] (a partir do 1, 3 números)
- range(0, 3) => [0,1,2]
- first(createArray(1,2,3)) => 1
- last(createArray(1,2,3)) => 3
- first('abc') => a (em texto, o primeiro caractere)
- last('abc') => c
- take(createArray(1,2,3), 2) => [1,2]
- skip(createArray(1,2,3), 1) => [2,3]
- union(createArray(1,2), createArray(2,3)) => [1,2,3] (sem repetir)
- intersection(createArray(1,2), createArray(2,3)) => [2]
- length(createArray(1,2,3)) => 3
- min(createArray(3,1,2)) => 1
- first(outputs('Dados')?['pedido']?['itens'])?['sku'] => A1 (primeiro item de uma lista de objetos)

Pegadinhas:
- range(início, quantidade): o segundo número é a quantidade, e não o último valor. range(1, 3) vai de 1 a 3; range(0, 3) vai de 0 a 2.
- first de lista vazia devolve nulo (não derruba o fluxo): confira antes de usar o resultado.
- Listas vazias não se criam com createArray(), que é inválido sem itens. Use json('[]').
- O loop Aplicar a cada roda um item por vez por padrão; mexer na concorrência pode causar o erro 429.

Quando usar: Use range para repetir algo um número fixo de vezes (parcelas, tentativas, páginas), alimentando um Aplicar a cada. Use first e last para pegar o primeiro ou o último item de uma lista, por exemplo o anexo certo de um e-mail depois de filtrar, e take e skip para paginar ou limitar listas grandes antes de processá-las, o que também reduz o número de ações do fluxo. union e intersection resolvem junções e conferências de duas listas sem loop. Sempre que possível, prefira essas funções e as ações Filtrar matriz e Selecionar a um loop, porque cada iteração de um loop conta como ações adicionais.

Fontes oficiais:
- Referência de funções de expressão do Power Automate e Logic Apps (Microsoft Learn): range, first, last, take e skip: https://learn.microsoft.com/azure/logic-apps/workflow-definition-language-functions-reference
- Otimize fluxos com execução paralela e simultaneidade (Microsoft Learn): https://learn.microsoft.com/power-automate/guidance/coding-guidelines/implement-parallel-execution

## if, and, or e not (Power Automate)

URL: https://meajudaflow.com.br/referencia/power-automate/if-and-or-not
Uso: if(condição, seVerdadeiro, seFalso)   and(a, b, …)   or(a, b, …)   not(a)

if escolhe entre dois valores conforme uma condição; and, or e not combinam condições. Todas devolvem verdadeiro/falso (ou o valor escolhido) e podem ser aninhadas livremente.

Exemplos executados de verdade no Power Automate (2026-11-02):
- if(equals(outputs('Dados')?['status'], 'Aprovado'), 'Sim', 'Não') => Sim (com status = Aprovado)
- if(and(equals(1,1), greater(2,1)), 'ok', 'no') => ok
- and(true, false) => false
- or(true, false) => true
- not(true) => false
- greater(2, 1) => true
- concat(if(equals(outputs('Dados')?['tipo'], 'Reembolso'), 'REE-', 'PAG-'), formatNumber(outputs('Dados')?['id'], '00000')) => REE-00042 (prefixo escolhido por tipo)

Pegadinhas:
- As condições respeitam as regras de maiúsculas de cada função: equals('Ana','ana') é falso. Veja comparações.
- Tipos diferentes não são iguais: equals(1, '1') é falso.
- O if só devolve valores; para ramificar ações, use a ação Condição.
- Aninhar demais atrapalha. Duas ou três camadas de if já merecem ser trocadas por uma ação Alternar (Switch).

Quando usar: Use if para escolher valores dentro de uma expressão (um prefixo de código, uma mensagem padrão, um valor entre dois) e a ação Condição quando for preciso decidir quais ações executar. Combine as condições com and e or em vez de empilhar vários if, e dê nomes claros às ações que guardam resultados intermediários, para que a lógica fique legível no histórico de execução. Comece pela condição mais restritiva, trate o caso padrão por último e teste cada ramo com dados reais, incluindo campos vazios. Se a mesma variável decide entre mais de três opções, a ação Alternar (Switch) fica muito mais fácil de manter.

Fontes oficiais:
- Referência de funções de expressão do Power Automate e Logic Apps (Microsoft Learn): if, and, or e not: https://learn.microsoft.com/azure/logic-apps/workflow-definition-language-functions-reference
- Use expressões em condições para verificar vários valores (Microsoft Learn): https://learn.microsoft.com/power-automate/use-expressions-in-conditions

# Regex para dados brasileiros

## Regex de CPF

URL: https://meajudaflow.com.br/regex/cpf/
Padrão: \d{3}\.\d{3}\.\d{3}-\d{2}|\d{11}

Regex para validar o formato de CPF com ou sem pontuação (000.000.000-00 ou 11 dígitos). Confere só a forma; os dígitos verificadores exigem cálculo.

Casa: 111.444.777-35 | 11144477735 | 529.982.247-25 | 39053344705
Não casa: 123.456.789-0 | 123.456.78910 | 1234567890 | abc.def.ghi-jk | 111.444.777-355

Armadilhas:
- O regex só confere o formato. Ele aceita 000.000.000-00 e qualquer sequência de onze dígitos, mesmo que os dois últimos não batam com o cálculo. Para saber se o CPF é matematicamente válido, use a ferramenta de validação com dígitos verificadores.
- Número com formato correto e dígitos corretos ainda pode não pertencer a ninguém. Só a Receita Federal sabe se o CPF existe e qual é a situação dele; nenhum regex nem cálculo responde isso.
- Em campos de formulário, as pessoas colam o CPF com espaços sobrando no começo ou no fim. Aplique trim antes de testar, ou o padrão ancorado recusará um número perfeitamente bom.
- No Python e no C#, o atalho \d aceita dígitos de outros alfabetos por padrão. Use [0-9] nesses ambientes, como nos trechos de código desta página, para ficar igual ao JavaScript.

Fontes (norma ou documento oficial):
- Receita Federal: folheto sobre o CPF e o CNPJ (CPF com onze dígitos; 9º dígito indica a Região Fiscal): https://www.gov.br/receitafederal/pt-br/assuntos/educacao-fiscal/educacao_fiscal/folhetos-orientativos/cadastros-dig.pdf
- Banco Central: Manual Operacional do DICT, chaves Pix (CPF: 11 números, sem pontos nem traços): https://www.bcb.gov.br/content/estabilidadefinanceira/pix/Regulamento_Pix/X_ManualOperacionaldoDICT.pdf

Limites das fontes:
- O cálculo dos dois dígitos verificadores (módulo 11) é prática consolidada, mas não encontramos um documento oficial aberto que o descreva; por isso o regex só confere a forma.

## Regex de CNPJ (numérico e alfanumérico)

URL: https://meajudaflow.com.br/regex/cnpj/
Padrão: [0-9A-Z]{2}\.[0-9A-Z]{3}\.[0-9A-Z]{3}/[0-9A-Z]{4}-\d{2}|[0-9A-Z]{12}\d{2}

Regex de CNPJ que aceita o formato numérico atual e o alfanumérico, com ou sem pontuação. Só o formato: os dígitos verificadores precisam de cálculo à parte.

Casa: 11.222.333/0001-81 | 11222333000181 | 12.ABC.345/01DE-35 | 1234567800NA84
Não casa: 11.222.333/0001-8 | 12.abc.345/01de-35 | 11222333000181X | 11.222.333-0001/81 | 12.ABC.345/01DE-AB

Armadilhas:
- Formato correto não é CNPJ válido. Os dois dígitos finais saem de um cálculo sobre os doze primeiros caracteres; no formato alfanumérico, cada letra entra no cálculo pelo seu código ASCII menos 48. Valide pelo cálculo, não pelo regex.
- Sistemas antigos que guardam o CNPJ como número inteiro perdem os zeros à esquerda e quebram quando surgem letras. Guarde sempre como texto de 14 caracteres.
- Colunas, campos e APIs limitados a dígitos recusarão o CNPJ alfanumérico. Confira também máscaras de entrada e validações de banco, não só o regex da aplicação.
- Um CNPJ bem formado pode estar baixado, inapto ou nem existir. A situação cadastral só se consulta na Receita Federal.

Fontes (norma ou documento oficial):
- Receita Federal: CNPJ terá letras e números a partir de julho de 2026 (IN RFB 2.229/2024): https://www.gov.br/receitafederal/pt-br/assuntos/noticias/2024/outubro/cnpj-tera-letras-e-numeros-a-partir-de-julho-de-2026
- Receita Federal: perguntas e respostas sobre o CNPJ alfanumérico (formato e cálculo do dígito): https://www.gov.br/receitafederal/pt-br/centrais-de-conteudo/publicacoes/perguntas-e-respostas/cnpj/cnpj-alfanumerico.pdf
- Instrução Normativa RFB nº 2.229, de 15/10/2024 (texto reproduzido no LEX): https://www.lex.com.br/instrucao-normativa-rfb-no-2-229-de-15-de-outubro-de-2024/

Limites das fontes:
- O Anexo XV da instrução normativa não pôde ser lido diretamente; as regras de formato foram conferidas no comunicado e nas perguntas e respostas oficiais da Receita.
- O LEX é uma reprodução do texto oficial; prefira o site da Receita quando disponível.

## Regex de telefone brasileiro

URL: https://meajudaflow.com.br/regex/telefone-brasileiro/
Padrão: (?:\+55\s?)?(?:\(?[1-9]\d\)?\s?)?(?:9\d{4}|[2-6]\d{3})-?\d{4}

Regex para telefone brasileiro, fixo ou celular, com ou sem DDD, parênteses, hífen e prefixo +55. Confere o formato, não se a linha existe.

Casa: (11) 91234-5678 | +55 11 91234-5678 | 11912345678 | (21) 2345-6789 | 91234-5678 | 2345-6789 | (11) 6234-5678
Não casa: (11) 1234-5678 | (00) 91234-5678 | 1191234567 | (11) 91234-567 | +44 11 91234-5678

Armadilhas:
- O padrão confere a forma, não a existência. Um número bem formado pode não estar em uso, e só um envio de teste confirma que a linha responde.
- Como o DDD é opcional, o padrão também aceita números locais sem DDD. Se o seu cadastro exige DDD, remova o grupo opcional ou valide o campo com uma regra à parte.
- Os DDDs aceitos vão de 11 a 99, sem consultar a lista oficial de códigos de área. Um DDD que não existe, como 20, passa pelo regex.
- Telefones internacionais com outro código de país não casam. Para um cadastro que receba números de fora, use uma biblioteca de telefonia internacional em vez de adaptar este padrão.

Fontes (norma ou documento oficial):
- Anatel: Resolução 749/2022, Regulamento de Numeração (texto reproduzido no Legisweb): https://www.legisweb.com.br/legislacao/?id=428952
- Banco Central: Manual Operacional do DICT (telefone no formato internacional E.164): https://www.bcb.gov.br/content/estabilidadefinanceira/pix/Regulamento_Pix/X_ManualOperacionaldoDICT.pdf

Limites das fontes:
- A norma destina os dígitos 7, 8 e 9 ao serviço móvel; este padrão exige o 9.
- Não consultamos a lista oficial de DDDs, então um DDD inexistente passa no regex.
- O texto da resolução tem alterações posteriores (por exemplo, em 2024 e 2025); confirme a versão vigente no site da Anatel.

## Regex de CEP

URL: https://meajudaflow.com.br/regex/cep/
Padrão: \d{5}-?\d{3}

Regex de CEP brasileiro, com ou sem hífen: cinco dígitos, hífen opcional e três dígitos. Só confere o formato; o endereço exige consulta a uma base de CEPs.

Casa: 01001-000 | 01001000 | 70040-010 | 30140071
Não casa: 1234-567 | 12345-67 | 123456789 | ab123-456 | 12345--678

Armadilhas:
- Oito dígitos com forma certa não são necessariamente um CEP que exista. Só uma consulta a uma base de endereços confirma que o código está atribuído.
- Aceitar o formato 00000-000 é inevitável com um regex simples. Se isso importa, adicione uma checagem extra para recusar o CEP todo zerado.
- Guarde o CEP como texto, nunca como número: CEPs começados em zero perdem o primeiro dígito quando viram inteiro, e 01001-000 vira 1001000.
- Sem âncoras, o padrão encontra CEP dentro de um número maior, como um código de rastreio de 13 dígitos. Use ^ e $ ao validar campos.

Fontes (norma ou documento oficial):
- Correios: Tudo sobre CEP (composição do código de oito algarismos): https://www.correios.com.br/enviar/precisa-de-ajuda/tudo-sobre-cep

Limites das fontes:
- Não consultamos a base oficial de CEPs: o regex confere só o formato.

## Regex de placa de veículo (antiga e Mercosul)

URL: https://meajudaflow.com.br/regex/placa-de-veiculo/
Padrão: [A-Z]{3}-?\d{4}|[A-Z]{3}\d[A-Z]\d{2}

Regex para placa de veículo brasileira nos dois modelos: antigo (ABC-1234) e Mercosul (ABC1D23). Confere só o formato, sem consultar o veículo.

Casa: ABC-1234 | ABC1234 | ABC1D23 | XYZ9K88
Não casa: AB1-2345 | abc1d23 | ABC-12D4 | ABCD123 | ABC1D2

Armadilhas:
- Certas combinações de letras podem não ser emitidas; o regex aceita qualquer letra de A a Z. Para saber se a placa existe é preciso consultar o órgão de trânsito.
- Os dois modelos têm sete caracteres, então a contagem de caracteres sozinha não os distingue. A posição da letra na quinta casa é o que identifica o Mercosul.
- Placas de motos, caminhões e veículos oficiais seguem a mesma estrutura de caracteres, mas variam em cores e tamanho físico. O regex trata apenas dos caracteres.
- Não confunda a placa com o RENAVAM nem com o chassi: são identificadores diferentes, com regras diferentes, e este padrão não serve para eles.

Fontes (norma ou documento oficial):
- Contran: Resolução 969/2022, sistema de Placas de Identificação de Veículos (texto reproduzido no Legisweb): https://www.legisweb.com.br/legislacao/?id=433068
- Contran: Resolução 969/2022 em PDF, com os anexos (cópia hospedada pelo Detran-PR): https://www.detran.pr.gov.br/sites/default/arquivos_restritos/files/documento/2022-07/resolucao_969_2022-contran.pdf

Limites das fontes:
- A Resolução 969/2022 revogou a Resolução Contran 780/2019, em vigor desde 01/07/2022.
- As duas fontes reproduzem o texto oficial; o site do órgão máximo executivo de trânsito da União é a referência primária.

## Regex de data brasileira (dd/mm/aaaa)

URL: https://meajudaflow.com.br/regex/data-brasileira/
Padrão: (?:0[1-9]|[12]\d|3[01])/(?:0[1-9]|1[0-2])/\d{4}

Regex para data no formato dd/mm/aaaa, com dia de 01 a 31 e mês de 01 a 12. Valida o intervalo, mas não os dias de cada mês nem ano bissexto.

Casa: 31/12/2026 | 01/01/1900 | 29/02/2024 | 15/08/2030
Não casa: 32/01/2026 | 00/10/2026 | 15/13/2026 | 1/1/2026 | 2026-12-31

Armadilhas:
- O regex aceita datas que não existem, como 31/02, 31/04 e 29/02 de ano comum. Depois do regex, converta para uma data de verdade e confira se o dia continua o mesmo; é o jeito confiável de rejeitar essas datas.
- Em JavaScript, new Date("05/03/2026") não tem comportamento garantido: formatos fora do padrão ISO ficam a critério do navegador e, na prática, costumam ser lidos com o mês primeiro. Nunca passe uma data brasileira direto ao construtor; separe dia, mês e ano com os grupos do regex e monte a data com eles.
- O padrão exige zero à esquerda. Quem digita 5/3/2026 é recusado. Se isso não for desejado, troque 0[1-9] por 0?[1-9] e ajuste o mês do mesmo modo.
- Datas com hora, como 05/03/2026 14:30, não casam quando o padrão está ancorado. Combine com o padrão de hora numa expressão maior, se precisar dos dois juntos.

Fontes (convenção de uso, sem norma oficial completa):
- IETF RFC 3339: datas e horas na internet (faixas válidas de mês e dia): https://www.rfc-editor.org/rfc/rfc3339
- MDN: Date.parse (formatos fora do padrão ISO dependem da implementação): https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/parse
- MDN: input type="date" (o valor é sempre AAAA-MM-DD): https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input/date

Limites das fontes:
- O formato dd/mm/aaaa é a convenção brasileira; não encontramos norma oficial aberta que o defina.

## Regex de hora (HH:MM e HH:MM:SS)

URL: https://meajudaflow.com.br/regex/hora/
Padrão: (?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d)?

Regex de hora no formato 24 horas, HH:MM ou HH:MM:SS, com horas de 00 a 23 e minutos e segundos de 00 a 59. Não trata AM e PM.

Casa: 08:30 | 23:59:59 | 00:00 | 12:45:07
Não casa: 24:00 | 8:30 | 12:60 | 12:5 | 12:30:61

Armadilhas:
- Em relógio de 24 horas, 24:00 às vezes aparece como fim do dia. O padrão o recusa de propósito; trate esse caso à parte se o seu sistema o produz.
- Duração não é hora do dia. Um total de 38:15 horas trabalhadas é válido como duração, mas este regex o recusa. Para somar horas, use um padrão sem limite no campo de horas.
- Fuso e horário de verão não existem para o regex. O texto 02:30 pode ser inexistente em dia de mudança de horário; isso só se resolve com biblioteca de datas.
- Formatos de 12 horas, como 8:30 PM, exigem outro padrão. Este não reconhece AM nem PM.

Fontes (especificação técnica aberta, sem norma brasileira):
- IETF RFC 3339: horas de 00 a 23, minutos de 00 a 59 (perfil do ISO 8601): https://www.rfc-editor.org/rfc/rfc3339

Limites das fontes:
- O RFC 3339 admite segundo 60 em segundo intercalado; este padrão aceita segundos de 00 a 59.
- Não encontramos norma brasileira aberta específica para a hora.

## Regex de e-mail (simplificado)

URL: https://meajudaflow.com.br/regex/email-simplificado/
Padrão: [A-Za-z0-9._%+-]+@[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)*\.[A-Za-z]{2,}

Regex simplificado de e-mail para triagem de campos de formulário. Pega erros óbvios; e-mail perfeito por regex é impraticável, a prova final é enviar uma mensagem.

Casa: ana@exemplo.com.br | joao.silva+nf@empresa.com | contato_01@mail.exemplo.org | a@b.co
Não casa: ana@ | @exemplo.com | ana@exemplo | ana exemplo@x.com | ana@@x.com

Armadilhas:
- Escrever um regex que aceite exatamente os e-mails válidos segundo a especificação é impraticável: a regra permite aspas, comentários e caracteres raros, e os provedores impõem restrições adicionais. Este padrão é uma triagem, não uma garantia.
- Ele recusa endereços legítimos pouco comuns, como os com acentos no usuário ou domínios internacionalizados. Se o seu público os usa, afrouxe o padrão e valide por envio.
- Aceita endereços que não existem, como ana@exemplo.com. A única forma confiável de saber é enviar uma mensagem com um link de confirmação e esperar o clique.
- Não use a validação como defesa de segurança. Passar no regex não torna a entrada segura para banco de dados, HTML ou cabeçalhos; trate a entrada separadamente.

Fontes (especificação técnica aberta, sem norma brasileira):
- WHATWG HTML: endereço de e-mail válido (input type="email"), com nota sobre o desvio deliberado do RFC 5322: https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address
- IETF RFC 5321 (SMTP): a parte local do endereço diferencia maiúsculas: https://www.rfc-editor.org/rfc/rfc5321

Limites das fontes:
- Este regex é mais restrito que a regra do navegador (WHATWG); ele não equivale ao input type="email".

## Regex de valor em reais (R$)

URL: https://meajudaflow.com.br/regex/valor-em-reais/
Padrão: R\$\s?(?:\d{1,3}(?:\.\d{3})*|\d+),\d{2}

Regex de valor em reais com prefixo R$, milhar com ponto e vírgula decimal com duas casas, como R$ 1.234,56. Serve para achar e conferir valores em texto.

Casa: R$ 1.234,56 | R$0,99 | R$ 10,00 | R$ 1234567,89
Não casa: R$ 1,234.56 | R$ 1.23,45 | 1.234,56 | R$ 12,3 | R$ -5,00

Armadilhas:
- O padrão confere a forma de um valor com dois decimais; não converte em número. Para calcular, remova os pontos de milhar, troque a vírgula por ponto e só então converta, preferindo trabalhar em centavos inteiros.
- Valores sem o prefixo R$, como 1.234,56, não casam. Isso é intencional, para não confundir com outros números, mas pode exigir uma variante sem prefixo em planilhas.
- O formato americano (1,234.56) é recusado. Ao importar dados de sistemas estrangeiros, converta o formato antes de aplicar a regra brasileira.
- Valores como R$ 1.000.000,00 passam, mas R$ 1.0000,00 não. Mesmo assim, o regex não limita o tamanho do valor; defina um teto de negócio à parte.

Fontes (convenção de uso, sem norma oficial completa):
- Lei nº 9.069/1995, art. 1º, §§ 1º e 2º: símbolo R$ e centavo escrito com vírgula: https://www.planalto.gov.br/ccivil_03/leis/l9069.htm

Limites das fontes:
- Só o símbolo R$ e a vírgula decimal têm base legal. O ponto de milhar, o espaço depois do R$ e as duas casas decimais são convenção de uso, sem norma oficial que encontramos.

## Regex de chave de acesso da NF-e (44 dígitos)

URL: https://meajudaflow.com.br/regex/chave-nfe-44-digitos/
Padrão: \d{6}[0-9A-Z]{12}\d{26}|\d{4} \d{2}[0-9A-Z]{2} [0-9A-Z]{4} [0-9A-Z]{4} [0-9A-Z]{2}\d{2}(?: \d{4}){6}

Regex para a chave de acesso de NF-e e outros documentos fiscais eletrônicos: 44 posições, com letras só no campo do CNPJ, juntas ou em 11 grupos de 4.

Casa: 35260111222333000181550010000012341123456788 | 3526 0111 2223 3300 0181 5500 1000 0012 3411 2345 6788 | 31261112345678000100550020000009871876543217 | 3126 1112 3456 7800 0100 5500 2000 0009 8718 7654 3217 | 35260112ABC34501DE35550010000012341123456789 | 3126 1112 3456 7800 NA84 5500 2000 0009 8718 7654 3217 | 3126111234567800NA84550020000009871876543217
Não casa: 3526011122233300018155001000001234112345678 | 352601112223330001815500100000123411234567880 | 35260111222333000181X50010000012341123456788 | 3526  0111 2223 3300 0181 5500 1000 0012 3411 2345 6788 | NFe35260111222333000181550010000012341123456788 | 352601112223330001X1550010000012341123456788 | 35260112abc34501de35550010000012341123456789 | 3B260112ABC34501DE35550010000012341123456789

Armadilhas:
- Quarenta e quatro posições com a forma certa não garantem uma chave válida. O último dígito é verificador, calculado pelo módulo 11 sobre as 43 anteriores (as letras entram com o código ASCII menos 48, segundo a Nota Técnica Conjunta 2025.001); o regex não faz essa conta, a ferramenta de decodificação faz.
- Uma chave com dígito correto ainda pode não corresponder a nenhuma nota autorizada. Só a consulta à Secretaria da Fazenda mostra se a nota existe e qual é a situação dela.
- Muitos sistemas colam a chave com o prefixo NFe, usado como identificador no XML. Remova o prefixo antes de aplicar o padrão, que espera só a chave.
- Guarde a chave sempre como texto. Como número, a chave estoura a precisão de inteiros em várias linguagens e perde zeros à esquerda.

Fontes (norma ou documento oficial):
- Nota Técnica Conjunta 2025.001 (ENCAT e Receita Federal): CNPJ alfanumérico, estrutura da chave de 44 posições e cálculo do dígito (cópia hospedada em reformatributaria.com): https://www.reformatributaria.com/wp-content/uploads/2025/05/CNPJ-alfanumerico.pdf

Limites das fontes:
- O Manual de Orientação do Contribuinte e o Portal Nacional da NF-e não puderam ser abertos; a fonte usada é uma cópia da nota técnica publicada por terceiros.
- O regex confere só a forma; o dígito verificador é conferido pela ferramenta do site.

## Regex de linha digitável de boleto (47 dígitos)

URL: https://meajudaflow.com.br/regex/linha-digitavel-boleto-47/
Padrão: \d{5}\.\d{5} \d{5}\.\d{6} \d{5}\.\d{6} \d \d{14}|\d{47}

Regex para a linha digitável de boleto bancário de 47 dígitos, com a pontuação e os espaços dos campos ou só os números. Não verifica os dígitos de controle.

Casa: 34191.00000 00000.000000 00000.000000 1 00000000000000 | 34191000000000000000000000000000100000000000000 | 23790.12345 67890.123456 78901.234567 8 00000012345678 | 23790123456789012345678901234567800000012345678
Não casa: 3419100000000000000000000000000010000000000000 | 341910000000000000000000000000001000000000000009 | 34191,00000 00000.000000 00000.000000 1 00000000000000 | 34191.0000000000.00000000000.000000100000000000000 | abc91000000000000000000000000000100000000000000

Armadilhas:
- O regex confere somente o formato. Os dígitos verificadores dos três primeiros campos e o geral seguem cálculos próprios, e só a ferramenta de decodificação os confere. As linhas dos exemplos têm formato correto, mas não foram emitidas por banco algum.
- Boletos de convênio e concessionárias têm 48 dígitos. Se o seu sistema recebe os dois tipos, adicione uma alternativa específica em vez de alargar este padrão.
- Linhas digitáveis copiadas de PDFs costumam vir com espaços a mais, quebras de linha ou pontos em outros lugares. Normalize (remover tudo que não é dígito) antes de testar o formato de 47 dígitos.
- O valor e o vencimento ficam nos últimos 14 dígitos, mas decodificá-los exige regras, como o fator de vencimento, que o regex não aplica.

Fontes (norma ou documento oficial):
- Banco Central: Carta-Circular 2.926/2000, bloqueto de cobrança (código de barras de 44 posições e linha digitável): https://www.bcb.gov.br/pre/normativos/c_circ/2000/pdf/c_circ_2926_v1_O.pdf
- Febraban: Layout padrão de arrecadação com código de barras, versão 8 (documentos que começam com 8): https://cmsarquivos.febraban.org.br/Arquivos/documentos/PDF/Layout%20-%20C%C3%B3digo%20de%20Barras%20-%20Vers%C3%A3o%208%20-%2011_05_2026.pdf

Limites das fontes:
- Os números 47 e 48 não aparecem escritos nesses documentos: são a soma dos tamanhos dos campos descritos.
- O cálculo do módulo 10 dos campos da linha digitável não foi confirmado em documento aberto; este regex confere só a forma.

## Regex de chave PIX aleatória (UUID)

URL: https://meajudaflow.com.br/regex/chave-pix-aleatoria/
Padrão: [0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}
Flags: i

Regex da chave PIX aleatória, que tem o formato de UUID: 32 caracteres hexadecimais em grupos 8-4-4-4-12 separados por hífen. Confere o formato, não a titularidade.

Casa: 123e4567-e89b-42d3-a456-426614174000 | 9F8B7C6D-5E4F-4A3B-8C2D-1E0F9A8B7C6D | 0a1b2c3d-4e5f-4a6b-9c7d-8e9f0a1b2c3d | c0ffee00-1234-4abc-8def-0123456789ab
Não casa: 123e4567e89b42d3a456426614174000 | 123e4567-e89b-42d3-a456-42661417400 | 123g4567-e89b-42d3-a456-426614174000 | 123e4567-e89b-42d3-a456-4266141740000 | {123e4567-e89b-42d3-a456-426614174000}

Armadilhas:
- Casar com o formato não prova que a chave está cadastrada no Banco Central. Para saber se uma chave existe e para quem aponta, só consultando o PIX, com o pagamento em curso.
- Chaves de CPF, CNPJ, telefone e e-mail têm outros formatos e precisam de outros padrões. No cadastro do Pix o telefone usa o formato internacional (+55...), mas, digitado por uma pessoa, um número de 11 dígitos pode ser CPF ou celular, e só o contexto desfaz a dúvida.
- Alguns sistemas guardam o UUID sem hífens. Se for o seu caso, normalize antes (adicionando os hífens) ou use uma variante de 32 caracteres hexadecimais corridos.
- Evite exibir ou registrar chaves aleatórias em logs públicos sem necessidade: elas identificam o destino de pagamentos de alguém.

Fontes (norma ou documento oficial):
- Banco Central: Manual Operacional do DICT, chaves Pix (chave aleatória é um UUID no formato da RFC 4122): https://www.bcb.gov.br/content/estabilidadefinanceira/pix/Regulamento_Pix/X_ManualOperacionaldoDICT.pdf
- IETF RFC 4122: formato textual do UUID (8-4-4-4-12): https://www.rfc-editor.org/rfc/rfc4122

Limites das fontes:
- O Manual não restringe a versão do UUID no texto consultado, por isso o regex aceita qualquer versão.
- A RFC 4122 foi substituída pela RFC 9562; o formato textual de 8-4-4-4-12 continua o mesmo.

## Regex de URL http e https

URL: https://meajudaflow.com.br/regex/url-http/
Padrão: https?://(?:[A-Za-z0-9-]+\.)+[A-Za-z]{2,}(?::\d{2,5})?(?:/[^\s]*)?

Regex para URLs http e https com domínio, porta opcional e caminho, útil para achar endereços em texto. Não cobre todos os casos da especificação de URL.

Casa: https://exemplo.com.br | http://www.exemplo.com:8080/a/b?x=1#topo | https://sub.dominio.exemplo.org/pagina | http://exemplo.io/
Não casa: ftp://exemplo.com | https://exemplo | https://exemplo .com | www.exemplo.com | https://.com

Armadilhas:
- Endereços como http://localhost:3000 e IPs numéricos não casam, porque o padrão exige uma terminação com letras. Se precisar deles, adicione alternativas específicas.
- Ao extrair URLs de texto corrido, o final da frase atrapalha: em "veja https://exemplo.com/a." o ponto final pode ser engolido pelo caminho. Remova pontuação do fim depois de achar a URL.
- Passar no regex não torna a URL segura. Links de phishing seguem esse formato. Não use este padrão como filtro de segurança nem abra links só porque o formato é válido.
- Domínios com acentos (internacionalizados) e esquemas como mailto: ou ftp: ficam de fora. Para análise rigorosa de URLs, o objeto URL do JavaScript é mais confiável que um regex.

Fontes (especificação técnica aberta, sem norma brasileira):
- IETF RFC 3986: sintaxe genérica de URI (esquema, host, porta, caminho): https://www.rfc-editor.org/rfc/rfc3986
- MDN: interface URL (base no padrão WHATWG URL): https://developer.mozilla.org/en-US/docs/Web/API/URL

Limites das fontes:
- O regex é mais restrito que a norma: a porta tem de dois a cinco dígitos e o endereço exige uma terminação, então localhost não casa.