> ## Documentation Index
> Fetch the complete documentation index at: https://www.notifuse.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Automações

> Crie fluxos automatizados que disparam a partir do comportamento e dos eventos dos contatos

![A lista de automações, com as jornadas, a conclusão e a taxa de abertura de cada automação](https://www.notifuse.com/docs/assets/screenshots/automation_list.png)

As automações de marketing são fluxos guiados por eventos: elas agem sobre um contato quando um evento específico acontece, como a inscrição em uma lista, a abertura de um email ou o registro de um evento personalizado. Use-as em sequências de boas-vindas, fluxos de onboarding e campanhas de reengajamento, ou para reagir a aberturas, cliques, retornos e eventos personalizados.

## Ciclo de vida de uma automação

Uma automação fica em um de três estados:

| Status       | Descrição                                                                          |
| ------------ | ---------------------------------------------------------------------------------- |
| **Rascunho** | Modo de criação e teste. Nenhum contato é inscrito.                                |
| **Ao Vivo**  | Automação ativa. Os contatos são inscritos quando os eventos do gatilho acontecem. |
| **Pausado**  | Interrompe as novas inscrições. As jornadas em andamento seguem até o fim.         |

**Fluxo de trabalho:**

1. Crie a automação no modo **Rascunho**
2. Configure o gatilho e adicione os nós
3. Clique em **Ativar** para colocá-la no ar e começar a inscrever contatos
4. Clique em **Pausar** quando precisar: os contatos ativos continuam a jornada
5. **Excluir** faz uma exclusão lógica da automação, que pode ser recuperada

### A lista de automações

A página **Automacoes** lista todas as automações com o status, o gatilho, as etapas e a lista de cada uma. As abas mostram as que estão ao vivo, pausadas ou em rascunho, e a busca encontra uma automação pelo nome ou pelo gatilho (uma lista, um segmento, o nome de um evento personalizado, um link clicado). Cada linha conta as jornadas desde a criação da automação: em andamento, iniciadas, a parcela das jornadas encerradas que foram concluídas e a que saiu, e o número das que falharam. A taxa de abertura cobre os emails da automação nos últimos 30 dias e exige a permissão de leitura de **Histórico de Mensagens**.

Ative ou pause uma automação pela sua linha; edite ou exclua enquanto ela não estiver ao vivo. Clicar em uma linha abre a automação no editor, com os resultados dela quando já foi executada.

## Gatilhos

Os gatilhos definem quando os contatos entram em uma automação, com base nos eventos da timeline do contato.

### Frequência do gatilho

| Frequência                       | Comportamento                                             |
| -------------------------------- | --------------------------------------------------------- |
| `once` (**Uma vez por contato**) | O contato só entra na primeira ocorrência do evento       |
| `every_time` (**Toda vez**)      | O contato pode entrar de novo a cada ocorrência do evento |

### Tipos de evento

As automações podem disparar com qualquer um destes eventos da timeline:

#### Eventos de contato

| Evento            | Descrição                            |
| ----------------- | ------------------------------------ |
| `contact.created` | Novo contato adicionado ao workspace |
| `contact.updated` | Campos do contato modificados        |
| `contact.deleted` | Contato removido do workspace        |

#### Eventos de lista

| Evento              | Descrição                                                       |
| ------------------- | --------------------------------------------------------------- |
| `list.subscribed`   | O contato se inscreveu em uma lista                             |
| `list.unsubscribed` | O contato cancelou a inscrição em uma lista                     |
| `list.confirmed`    | O contato confirmou a inscrição (confirmação dupla)             |
| `list.resubscribed` | Um contato que tinha cancelado a inscrição se inscreveu de novo |
| `list.bounced`      | O email enviado ao contato retornou                             |
| `list.complained`   | O contato marcou o email como spam                              |
| `list.pending`      | O contato está aguardando confirmação                           |
| `list.removed`      | O contato foi removido da lista                                 |

> [!TIP]
>
> Os eventos de lista exigem escolher uma lista específica na configuração do gatilho.

#### Eventos de segmento

| Evento           | Descrição                                             |
| ---------------- | ----------------------------------------------------- |
| `segment.joined` | O contato passou a atender aos critérios do segmento  |
| `segment.left`   | O contato deixou de atender aos critérios do segmento |

#### Eventos de email

| Evento               | Descrição                                                                   |
| -------------------- | --------------------------------------------------------------------------- |
| `email.opened`       | O contato abriu o email                                                     |
| `email.clicked`      | O contato clicou em um link do email                                        |
| `email.link_clicked` | O contato clicou em um link de um email pela primeira vez, uma vez por link |
| `email.bounced`      | O email retornou                                                            |
| `email.complained`   | O contato marcou como spam                                                  |
| `email.unsubscribed` | O contato cancelou a inscrição pelo link do email                           |

#### Eventos personalizados

| Evento         | Descrição                                   |
| -------------- | ------------------------------------------- |
| `custom_event` | Evento definido por você e enviado pela API |

> [!TIP]
>
> Os eventos personalizados exigem informar o nome do evento (por exemplo, `purchase`, `trial_started`).

Uma automação começa quando um evento é registrado pela primeira vez. Desde a versão 44.0, atualizar, excluir ou restaurar um evento que mantém o mesmo `external_id` não a inicia de novo. Para iniciá-la em uma nova ocorrência (uma renovação, um segundo pedido), envie o evento com um novo `external_id`.

### Gatilhos por campo

Nos eventos `contact.updated`, você pode filtrar pelos campos específicos que mudaram:

**Campos principais:** `first_name`, `last_name`, `phone`, `external_id`, `timezone`, `language`, `photo_url`

**Campos de endereço:** `address_line_1`, `address_line_2`, `country`, `state`, `postcode`

**Campos personalizados:**

- Texto: `custom_string_1` a `custom_string_5`
- Número: `custom_number_1` a `custom_number_5`
- Data: `custom_datetime_1` a `custom_datetime_5`
- JSON: `custom_json_1` a `custom_json_5`

### Gatilhos de clique em link

`email.link_clicked` (**Clicou em um link** no console) inicia uma automação quando um contato clica em um link
específico. Por exemplo, para adicionar a uma lista que alimenta uma sequência de acompanhamento todos os que clicaram
no link da sua página de preços. `email.clicked` acontece uma vez por email, no primeiro clique. Já
`email.link_clicked` acontece na primeira vez que o contato clica em cada link do email, então o link de preços inicia
a automação mesmo que o contato tenha clicado antes em outro link. Clicar de novo no mesmo link não a inicia.

Três filtros opcionais restringem o gatilho:

| Campo          | Console               | Corresponde a                                                                                                                                                                  |
| -------------- | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `link_url`     | O link clicado contém | Links cuja URL contém este texto, sem diferenciar maiúsculas de minúsculas. A URL registrada mantém os parâmetros UTM, então busque por uma parte do endereço, como `/pricing` |
| `broadcast_id` | Broadcast             | Links dos emails deste broadcast                                                                                                                                               |
| `template_id`  | Template              | Links dos emails enviados com este template                                                                                                                                    |

```json
{
  "event_kind": "email.link_clicked",
  "link_url": "/pricing",
  "broadcast_id": "YOUR_BROADCAST_ID",
  "frequency": "once"
}
```

Um clique em um email enviado pela própria automação nunca a inicia de novo. Assim, uma automação configurada como
`every_time` não entra em loop com os links dos próprios emails.

Os links para a sua instância do Notifuse nunca a iniciam, e o Notifuse compara os nomes de host sem considerar a
porta. Então um link para o seu blog servido no seu domínio personalizado, ou para outro site no mesmo nome de host da
sua instância, não inicia nada. Veja em [Rastreamento de email](https://www.notifuse.com/pt/docs/features/email-tracking.md) quais links não registram
clique.

> [!NOTE]
>
> Só os cliques que o Notifuse consegue verificar iniciam a automação: os cliques nos links assinados dos emails enviados
> a partir da versão 42.2. Os cliques feitos antes da atualização para a 44.0 não são reprocessados, mas um link clicado
> antes da atualização inicia a automação no próximo clique. Veja [o que registra um clique em link](https://www.notifuse.com/pt/docs/features/email-tracking.md#link-clicks).

> [!NOTE]
>
> Alguns scanners de segurança de email seguem todos os links dos emails que entregam. O Notifuse descarta os cliques que
> reconhece como automatizados, e um scanner que ele não reconhece inicia a automação como um contato faria.

### Gatilhos condicionais

Adicione condições de segmento para filtrar quais contatos entram na automação. Por exemplo:

- Disparar com `list.subscribed`, mas só para contatos com `country = "US"`
- Disparar com `contact.updated`, mas só quando `custom_number_1 > 100`

Defina as condições no painel do gatilho, em **Condições de entrada**, ou pela API com o campo `conditions`.

![O painel do gatilho de uma automação: o evento Lista / Inscrito na lista Newsletter, com uma condição de entrada](https://www.notifuse.com/docs/assets/screenshots/automation_trigger.png)

Elas usam o mesmo construtor de condições dos segmentos e do nó Filtro.

Um contato que não atende às condições nunca é inscrito, o que é diferente de um nó Filtro depois do gatilho. Com
**Uma vez por contato**, um contato inscrito e depois enviado pelo caminho "Não" de um nó Filtro já usou a sua única
inscrição e não pode entrar mais tarde. Com uma condição de entrada, a inscrição continua disponível.

> [!NOTE]
>
> Uma condição que conta a atividade da timeline inclui o evento que disparou o gatilho. Assim, "abriu pelo menos 3
> emails" em um gatilho `email.opened` inscreve o contato na terceira abertura, não na quarta. Quando vários eventos são
> registrados na mesma operação, como em uma importação em massa, as condições de cada um enxergam todos eles.

## Tipos de nó

Os nós são as etapas de um fluxo: nós de ação (fluxo linear) ou nós de ramificação (vários caminhos).

Todo nó também aceita uma **descrição** opcional, uma nota curta sua definida no topo do painel de configuração. Ela aparece como título do nó na tela e no painel, para que você entenda o que uma sequência de nós Email e Atraso faz sem abrir cada um. Ela não tem efeito na execução.

### Nós de ação

| Nó                    | Finalidade                                  | Configuração principal                                |
| --------------------- | ------------------------------------------- | ----------------------------------------------------- |
| **Gatilho**           | Ponto de entrada da automação               | `event_kind` (obrigatório), `frequency`, `conditions` |
| **Atraso**            | Pausa a execução por um tempo               | `duration` (1-365), `unit` (minutos/horas/dias)       |
| **Email**             | Envia um template ao contato                | `template_id` (obrigatório)                           |
| **Adicionar à lista** | Inscreve o contato em uma lista             | `list_id`, `status` (`active` ou `pending`)           |
| **Remover da lista**  | Cancela a inscrição do contato em uma lista | `list_id`                                             |
| **Webhook**           | Envia um HTTP POST para uma URL externa     | `url` (obrigatório), `secret` (token Bearer opcional) |

### Nós de ramificação

| Nó                                  | Finalidade                                  | Configuração principal                                         |
| ----------------------------------- | ------------------------------------------- | -------------------------------------------------------------- |
| **Filtro**                          | Direciona com base em condições (Sim/Não)   | `conditions`, caminhos para quem atende e para quem não atende |
| **Teste A/B**                       | Divide os contatos para testes              | 2 a 4 `variants` com pesos (a soma deve dar 100%)              |
| **Ramificação por status na lista** | Direciona pelo status de inscrição na lista | `list_id`, 3 caminhos: fora da lista, ativo, não ativo         |

### Detalhes dos nós

#### Nó Atraso

Pausa a jornada do contato por um tempo definido e depois segue para o próximo nó.

- **Duração**: de 1 a 365
- **Unidade**: `minutes`, `hours` ou `days`

**Exemplo**: esperar 24 horas depois do cadastro antes de enviar o email de boas-vindas.

#### Nó Email

Envia um template de email ao contato.

- **ID do Template**: obrigatório. Escolha entre os templates do workspace.
- **Assunto e remetente**: sempre os do template. A API aceita `subject_override` e `from_override` no nó, mas o envio os ignora.

> [!WARNING]
>
> Os nós Email exigem uma lista na automação, para que cada contato tenha um contexto de inscrição.

O template pode usar o evento que iniciou a jornada como `{{ trigger_event }}`: as propriedades de um evento personalizado (`{{ trigger_event.properties.items }}`), a lista ou o segmento em que o contato entrou, ou o link clicado. Veja [Variáveis de automação](https://www.notifuse.com/pt/docs/features/templates.md#automation-variables). As jornadas iniciadas antes da versão 44 não têm `trigger_event`.

A lista da automação não limita quem recebe os emails. Um email de marketing só é pulado para os contatos que cancelaram a inscrição, tiveram retorno ou reclamaram nessa lista. Os contatos sem inscrição nela também recebem o email.

O link de cancelamento do email registra esses contatos na lista como inscrição cancelada, e os emails de marketing seguintes da automação os fazem sair. Para enviar só aos inscritos da lista, coloque uma [Ramificação por status na lista](#list-status-branch-node) antes do nó Email e deixe o caminho **Não está na Lista** sem conexão, o que encerra a automação para os contatos fora da lista.

#### Nó Filtro

Direciona os contatos com base em condições de segmento. Os contatos que atendem às condições seguem pelo caminho "Sim"; os outros seguem pelo caminho "Não" ou saem.

Ele usa o mesmo construtor de condições dos segmentos, com campos do contato, eventos personalizados e lógica AND/OR aninhada.

#### Nó Teste A/B

Divide os contatos em variantes para testar caminhos diferentes.

- **Variantes**: de 2 a 4 variantes (A, B, C, D)
- **Pesos**: cada variante tem um peso (1-100%), e a soma deve dar 100%
- **Determinístico**: o mesmo contato no mesmo nó sempre cai na mesma variante (usa o hash FNV-32a)

**Exemplo**: testar dois templates de email com uma divisão de 50/50.

#### Nó Ramificação por status na lista

Direciona os contatos pelo status de inscrição deles em uma lista específica:

| Caminho               | Condição                                                                    |
| --------------------- | --------------------------------------------------------------------------- |
| **Não está na Lista** | O contato não está inscrito na lista                                        |
| **Ativo**             | O contato tem o status `active` na lista                                    |
| **Não Ativo**         | O contato tem o status `pending`, `unsubscribed`, `bounced` ou `complained` |

#### Nó Webhook

Envia dados do contato e da automação para uma URL externa via HTTP POST.

- **URL**: obrigatória. Deve começar com `http://` ou `https://`
- **Segredo**: opcional. Enviado no cabeçalho `Authorization: Bearer {secret}`

O payload inclui os dados do contato, o contexto da automação e metadados da execução.

O destino precisa estar acessível pela internet pública. O Notifuse se recusa a conectar em endereços privados, de loopback, link-local e reservados, incluindo o endpoint de metadados da instância na nuvem. Ele verifica de novo a cada redirecionamento, então uma URL pública que redireciona para uma interna também é recusada.

O editor marca o nó Webhook cuja URL aponta para um desses endereços, e a automação não pode ser salva até que isso seja corrigido. Uma etapa recusada assim é tentada de novo como qualquer outra etapa com falha e depois faz a jornada do contato falhar.

> [!NOTE]
>
> Só em instalações auto-hospedadas: para enviar de propósito a um serviço da sua rede privada (um container na mesma rede Docker, uma ferramenta interna de automação), defina `WEBHOOK_DELIVERY_ALLOW_PRIVATE_HOSTS=true`. Não defina essa variável em uma instalação onde alguém a quem você não confiaria a sua rede interna pode editar automações.

## Editor visual de fluxos

![O editor de automações, com o painel de uma etapa de email aberto](https://www.notifuse.com/docs/assets/screenshots/automation.png)

O editor abre em tela cheia sobre a lista e tem um link próprio, que abre a mesma automação para quem você o compartilhar. A coluna da esquerda reúne as configurações da automação (a lista, a frequência e [Sair ao responder](#exit-on-reply)) e as etapas que você pode adicionar, agrupadas em **Acoes** e **Lógica**. A tela mostra o fluxo, com controles de zoom, um minimapa e **Reorganizar layout**.

### Montando fluxos

1. **Comece pelo gatilho**: toda automação começa com um nó de gatilho
2. **Adicione nós**: arraste uma etapa da coluna da esquerda para a tela, ou use o "+" abaixo de uma saída sem conexão
3. **Conecte os nós**: arraste conexões entre os nós; cada caminho de um filtro, de um teste A/B ou de um status na lista tem seu rótulo na ligação
4. **Configurar**: clique em um nó para abrir o painel dele, com a descrição, as configurações e a prévia do email em uma etapa de email. Para remover uma etapa, selecione o cartão dela na tela e clique no botão de lixeira (**Excluir nó**) ao lado.

Uma etapa Email precisa antes da lista da automação: escolha a lista na coluna da esquerda.

### Salvando

**Criar** salva uma nova automação e, depois, **Salvar** grava as suas alterações (⌘S ou Ctrl+S). Desfazer e refazer são ⌘Z e ⇧⌘Z. A barra mostra **Alterações não salvas** até você salvar, e **Ativar** espera que elas sejam salvas. Fechar o editor ou sair da página com alterações não salvas pede confirmação antes.

Uma automação ao vivo abre somente para leitura: pause-a para editar. Se outra pessoa alterou a automação enquanto você a editava, o salvamento é recusado e o editor oferece recarregá-la.

## Sair ao responder

Quando um contato responde a um email de uma automação, em geral você quer parar o resto da sequência em vez de mandar os emails agendados para alguém que já respondeu. É isso que **Sair ao responder** faz.

### Como ativar

Ative **Sair ao responder** nas configurações da automação, na coluna da esquerda do editor, ao criá-la ou editá-la. Com a opção ligada, uma resposta real a qualquer email enviado pela automação faz o contato sair da jornada, com o motivo de saída `replied`.

![As configurações da automação: lista, frequência e a opção Sair ao responder ativada](https://www.notifuse.com/docs/assets/screenshots/automation_exit_on_reply.png)

> [!WARNING]
>
> **Sair ao responder exige configurar o recebimento de emails no seu provedor de email.** O recurso de leitura de emails recebidos do provedor encaminha as respostas de volta ao Notifuse. Hoje isso funciona com o Mailgun (veja [Mailgun → Respostas recebidas](https://www.notifuse.com/pt/docs/integrations/mailgun.md#inbound-replies-stop-on-reply)) e o Amazon SES (veja [Amazon SES → Respostas recebidas](https://www.notifuse.com/pt/docs/integrations/amazon-ses.md#inbound-replies-stop-on-reply)), cada um com uma configuração única. Nos outros provedores, a opção não tem efeito até que o recebimento esteja configurado.

### Como as respostas são associadas

O Notifuse associa uma resposta ao email exato que ela responde comparando os cabeçalhos padrão de encadeamento (`In-Reply-To` / `References`) com o `Message-ID` definido no envio. Por isso:

- O contato sai só da automação à qual respondeu. Um contato inscrito em várias automações que responde a uma delas continua nas outras.
- As respostas que não correspondem a nenhum envio conhecido são ignoradas, e nenhuma jornada termina.

### O que conta como resposta

Nem toda mensagem recebida é tratada como resposta:

| Tipo de mensagem                          | Efeito                                                                    |
| ----------------------------------------- | ------------------------------------------------------------------------- |
| Uma resposta real de uma pessoa           | Faz o contato sair da jornada (quando **Sair ao responder** está ativado) |
| Resposta automática de ausência ou férias | Registrada na timeline, mas nunca faz o contato sair                      |
| Retorno ou relatório de status de entrega | Descartado                                                                |

As respostas associadas aparecem na timeline do contato como `email.replied` (ou `email.auto_reply` para as respostas automáticas).

> [!NOTE]
>
> A parada vale mesmo quando o próximo email está no meio de um atraso ou já na fila de envio, então um contato que responde não recebe o próximo email agendado.

## Jornadas dos contatos

O avanço de cada contato em uma automação é acompanhado como uma "jornada", com o histórico completo da execução.

### Estados da jornada

| Status      | Descrição                                                                             |
| ----------- | ------------------------------------------------------------------------------------- |
| `active`    | Avançando pela automação neste momento                                                |
| `completed` | Chegou a um nó final (terminou o fluxo)                                               |
| `exited`    | Saiu antes por causa de um filtro, de um cancelamento de inscrição ou de uma exclusão |
| `failed`    | Erro depois do número máximo de tentativas                                            |

### Motivos de saída

Quando um contato sai antes do fim, o motivo fica registrado:

| Motivo              | Descrição                                                                                                   |
| ------------------- | ----------------------------------------------------------------------------------------------------------- |
| `completed`         | Conclusão normal em um nó final                                                                             |
| `filter_rejected`   | Nunca registrado. Um contato reprovado em um nó Filtro sem caminho "Não" termina a jornada como `completed` |
| `unsubscribed`      | O contato cancelou a inscrição na lista da automação                                                        |
| `replied`           | O contato respondeu a um dos emails da automação (exige **Sair ao responder**)                              |
| `automation_paused` | A automação foi pausada enquanto o contato estava ativo                                                     |
| `manual`            | Removido manualmente por um admin                                                                           |

### Eventos da timeline

A atividade das automações é registrada na timeline do contato:

- `automation.start`: o contato foi inscrito na automação
- `automation.end`: o contato concluiu, saiu ou falhou

## Motor de execução

As automações rodam em um agendador em segundo plano, que faz os contatos avançarem pelos fluxos.

### Como funciona

1. **Consulta periódica**: o agendador roda a cada 10 segundos
2. **Lotes**: os contatos são processados em lotes, por eficiência
3. **Distribuição justa**: rodízio entre os workspaces

### Processamento dos nós

- **Execução de vários nós**: até 10 nós processados por ciclo (evita loops descontrolados)
- **Recuperação após falha**: o estado é gravado depois de cada nó
- **Tratamento dos atrasos**: os nós Atraso agendam a execução futura no horário `scheduled_at`

### Lógica de novas tentativas

Quando a execução de um nó falha:

1. O contador de tentativas aumenta
2. Uma nova tentativa é agendada com espera exponencial: 2 minutos depois da primeira falha, depois 4 minutos
3. Depois do número máximo de tentativas (padrão: 3), a jornada fica como `failed`

## Estatísticas

### Estatísticas por automação

A [lista de automações](#the-automations-list) mostra as jornadas de cada automação desde a criação:

| Estatística          | Descrição                                                                                                |
| -------------------- | -------------------------------------------------------------------------------------------------------- |
| **Em andamento**     | Contatos em jornada neste momento                                                                        |
| **Entraram**         | Todas as jornadas iniciadas, qualquer que seja o status                                                  |
| **Concluído**        | Parcela das jornadas encerradas que chegaram ao fim                                                      |
| **Saiu**             | Parcela das jornadas encerradas que saíram antes (um filtro, uma resposta, um cancelamento de inscrição) |
| **Falhou**           | Jornadas que falharam depois das novas tentativas                                                        |
| **Taxa de abertura** | Aberturas sobre os emails com abertura rastreada, nos últimos 30 dias                                    |

Um rascunho em que nenhum contato entrou mostra "—". A API dá as mesmas contagens com `automations.list` e `with_journey_counts=true`.

### Estatísticas por nó

![O editor com as estatísticas ligadas, mostrando os resultados de cada etapa no seu cartão](https://www.notifuse.com/docs/assets/screenshots/automation_stats.png)

Ligue a opção **Estatísticas** no editor para ver os resultados de cada etapa em **7 d**, **30 d** (hoje incluído, no fuso horário do workspace) ou **Todo o período**. Cada cartão mostra o número principal (passagens no gatilho, que conta uma jornada a cada vez que um loop a traz de volta; enviados, com aberturas e cliques; aguardando; verificados; adicionados ou removidos; chamadas), com as jornadas que falharam, que estão em nova tentativa ou ainda em andamento nele, e os emails pulados. Cada caminho de uma divisão mostra a parcela das passagens da etapa que o seguiu.

O painel de uma etapa traz o detalhe:

- **Alcançados**: quantas vezes as jornadas chegaram à etapa. Uma jornada que volta em loop conta a cada volta, e uma nova tentativa conta como a mesma passagem. Em um período, a passagem é datada pela tentativa bem-sucedida ou, se não houver, pela última tentativa. Uma passagem cuja nova tentativa dá certo em um período posterior passa para esse período, então o valor de Alcançados de um período anterior pode cair e ficar só com as tentativas que falharam
- **Concluído**: execuções que terminaram
- **Em andamento**, **Aguardando** e **Tentando novamente**: jornadas na etapa agora, qualquer que seja o período
- **Falhou**: jornadas que falharam na etapa
- **Erros**: execuções que registraram um erro, como uma etapa de lista cuja lista foi excluída

![Os resultados de uma etapa de email nos últimos 30 dias: enviados, entregues, abertos e clicados, depois alcançados, concluídos, em andamento e com falha](https://www.notifuse.com/docs/assets/screenshots/automation_step_stats.png)

Uma etapa de email acrescenta os emails dela: enviados, entregues, abertos e clicados, depois os que falharam, retornaram ou cancelaram a inscrição, os que estão na fila e os não enviados, com **Ver mensagens** para abri-los no log de mensagens. O SMTP não informa entrega, então essa linha mostra "—". Os números de email exigem a permissão de leitura de **Histórico de Mensagens**.

Uma etapa adicionada depois do último salvamento não tem o que contar até você salvar. A API dá os mesmos números com `automations.nodeStats`.

## Permissões

As automações seguem a permissão **Automacoes**: a **leitura** abre as automações e os grafos completos dos nós, as estatísticas de cada etapa (`automations.nodeStats`) e a jornada de um contato específico; a **escrita** cria, edita e exclui automações, e as ativa ou pausa. Sem escrita, o editor abre somente para leitura. Os números de email das estatísticas e a taxa de abertura também exigem a leitura de **Histórico de Mensagens**, e a prévia do email exige a leitura de **Templates**.

> [!WARNING]
>
> **A escrita de Automações vai além da própria área.** Um nó Webhook envia o registro completo do
> contato para qualquer URL que a automação indicar, e nada verifica permissões enquanto uma automação
> roda. Por isso, esta permissão é uma leitura indireta de contatos que a leitura de Contatos não
> consegue restringir. Os outros nós adicionam contatos a listas, os removem e enviam email, sem
> nenhuma concessão de Listas ou de Transacional.
>
> **A leitura de Automações expõe segredos.** A configuração dos nós que ela retorna inclui a URL de
> cada nó Webhook e o segredo bearer salvo nele.

Veja [Admins e chaves API](https://www.notifuse.com/pt/docs/features/admins-api-keys.md).

## Boas práticas

1. **Comece simples**: comece com gatilho → atraso → email e depois aumente a complexidade
2. **Use filtros com critério**: segmente os contatos dentro dos fluxos para mandar mensagens direcionadas
3. **Teste antes de colocar no ar**: use uma pequena lista de teste antes de ativar em produção
4. **Acompanhe as estatísticas**: confira com frequência as contagens de inscritos, concluídos e com falha
5. **Consulte os logs de execução**: investigue problemas pelo histórico da jornada do contato
6. **Dê nomes claros**: use nomes descritivos para identificar as automações com facilidade
7. **Pense na frequência**: escolha entre `once` e `every_time` conforme o seu caso de uso
