> ## 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.

# Automazioni

> Crea flussi automatici che partono in base al comportamento dei contatti e agli eventi

![L'elenco delle automazioni, con i percorsi, il tasso di completamento e il tasso di apertura di ciascuna](https://www.notifuse.com/docs/assets/screenshots/automation_list.png)

Le automazioni di marketing sono flussi guidati dagli eventi: agiscono su un contatto quando si verifica un evento preciso, come l'iscrizione a una lista, l'apertura di un'email o la registrazione di un evento personalizzato. Usale per sequenze di benvenuto, flussi di onboarding e campagne di riattivazione, oppure per reagire ad aperture, click, bounce ed eventi personalizzati.

## Ciclo di vita di un'automazione

Un'automazione si trova in uno di questi tre stati:

| Stato        | Descrizione                                                                                       |
| ------------ | ------------------------------------------------------------------------------------------------- |
| **Bozza**    | Modalità di costruzione e di prova. Nessun contatto viene iscritto.                               |
| **Attivo**   | Automazione in funzione. I contatti vengono iscritti quando si verificano gli eventi del trigger. |
| **In Pausa** | Blocca le nuove iscrizioni. I percorsi già avviati proseguono fino alla fine.                     |

**Flusso di lavoro:**

1. Crea l'automazione in modalità **Bozza**
2. Configura il trigger e aggiungi i nodi
3. Usa **Attiva** per metterla in funzione e iniziare a iscrivere i contatti
4. Usa **Pausa** quando serve: i contatti già attivi proseguono il loro percorso
5. **Elimina** esegue un'eliminazione logica dell'automazione, che si può recuperare

### L'elenco delle automazioni

La pagina **Automazioni** elenca tutte le automazioni con stato, trigger, passaggi e lista. Le schede mostrano quelle attive, in pausa o in bozza, e la ricerca trova un'automazione per nome o per trigger (una lista, un segmento, il nome di un evento personalizzato, un link cliccato). Ogni riga conta i percorsi dalla creazione dell'automazione: quelli in corso, quelli entrati, la quota dei percorsi conclusi che è arrivata alla fine e quella che è uscita prima, e il numero di quelli falliti. Il tasso di apertura copre le sue email degli ultimi 30 giorni e richiede il permesso di lettura su **Cronologia Messaggi**.

Puoi attivare o mettere in pausa un'automazione dalla sua riga, e modificarla o eliminarla quando non è attiva. Fai clic su una riga per aprire l'automazione nel suo editor, con i risultati se è già stata eseguita.

## Trigger

I trigger stabiliscono quando i contatti entrano in un'automazione, in base agli eventi della timeline del contatto.

### Frequenza del trigger

| Frequenza                           | Comportamento                                                 |
| ----------------------------------- | ------------------------------------------------------------- |
| `once` (**Una volta per contatto**) | Il contatto entra solo alla prima occorrenza dell'evento      |
| `every_time` (**Ogni volta**)       | Il contatto può rientrare ogni volta che l'evento si verifica |

### Tipi di evento

Le automazioni possono partire da uno qualsiasi di questi eventi della timeline:

#### Eventi del contatto

| Evento            | Descrizione                          |
| ----------------- | ------------------------------------ |
| `contact.created` | Nuovo contatto aggiunto al workspace |
| `contact.updated` | Campi del contatto modificati        |
| `contact.deleted` | Contatto rimosso dal workspace       |

#### Eventi delle liste

| Evento              | Descrizione                                                  |
| ------------------- | ------------------------------------------------------------ |
| `list.subscribed`   | Il contatto si è iscritto a una lista                        |
| `list.unsubscribed` | Il contatto si è disiscritto da una lista                    |
| `list.confirmed`    | Il contatto ha confermato l'iscrizione (double opt-in)       |
| `list.resubscribed` | Un contatto disiscritto in precedenza si è iscritto di nuovo |
| `list.bounced`      | L'email al contatto è stata respinta                         |
| `list.complained`   | Il contatto ha segnalato l'email come spam                   |
| `list.pending`      | Il contatto è in attesa di conferma                          |
| `list.removed`      | Il contatto è stato rimosso dalla lista                      |

> [!TIP]
>
> Gli eventi delle liste richiedono di scegliere una lista specifica nella configurazione del trigger.

#### Eventi dei segmenti

| Evento           | Descrizione                                         |
| ---------------- | --------------------------------------------------- |
| `segment.joined` | Il contatto soddisfa i criteri del segmento         |
| `segment.left`   | Il contatto non soddisfa più i criteri del segmento |

#### Eventi email

| Evento               | Descrizione                                                                        |
| -------------------- | ---------------------------------------------------------------------------------- |
| `email.opened`       | Il contatto ha aperto l'email                                                      |
| `email.clicked`      | Il contatto ha cliccato un link nell'email                                         |
| `email.link_clicked` | Il contatto ha cliccato per la prima volta un link di un'email, una volta per link |
| `email.bounced`      | L'email è stata respinta                                                           |
| `email.complained`   | Il contatto l'ha segnalata come spam                                               |
| `email.unsubscribed` | Il contatto si è disiscritto dal link nell'email                                   |

#### Eventi personalizzati

| Evento         | Descrizione                                 |
| -------------- | ------------------------------------------- |
| `custom_event` | Evento definito da te e inviato tramite API |

> [!TIP]
>
> Gli eventi personalizzati richiedono di indicare il nome dell'evento (ad esempio `purchase`, `trial_started`).

Un'automazione parte quando un evento viene registrato per la prima volta. Dalla 44.0, aggiornare, eliminare o ripristinare un evento che mantiene il suo `external_id` non la fa ripartire: per avviarla su una nuova occorrenza (un rinnovo, un secondo ordine), invia l'evento con un nuovo `external_id`.

### Trigger su campi specifici

Per gli eventi `contact.updated` puoi filtrare in base ai campi modificati:

**Campi principali:** `first_name`, `last_name`, `phone`, `external_id`, `timezone`, `language`, `photo_url`

**Campi dell'indirizzo:** `address_line_1`, `address_line_2`, `country`, `state`, `postcode`

**Campi personalizzati:**

- Stringa: da `custom_string_1` a `custom_string_5`
- Numero: da `custom_number_1` a `custom_number_5`
- Data: da `custom_datetime_1` a `custom_datetime_5`
- JSON: da `custom_json_1` a `custom_json_5`

### Trigger sul click di un link

`email.link_clicked` (**Ha cliccato un link** nella console) avvia un'automazione quando un contatto clicca un certo link,
ad esempio per aggiungere chi ha cliccato il link della pagina prezzi a una lista che alimenta una sequenza di follow-up.
`email.clicked` si verifica una volta per email, al primo click; `email.link_clicked` si verifica la prima volta che un
contatto clicca ciascun link dell'email, quindi il link dei prezzi avvia l'automazione anche se il contatto ha cliccato
prima un altro link. Un nuovo click sullo stesso link non la avvia.

Tre filtri facoltativi lo restringono:

| Campo          | Console                   | Corrisponde a                                                                                                                                                                          |
| -------------- | ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `link_url`     | Il link cliccato contiene | I link il cui URL contiene questo testo, senza distinzione tra maiuscole e minuscole. L'URL registrato conserva i parametri UTM, quindi cerca una parte dell'indirizzo come `/pricing` |
| `broadcast_id` | Broadcast                 | I link nelle email di questo broadcast                                                                                                                                                 |
| `template_id`  | Template                  | I link nelle email inviate con questo template                                                                                                                                         |

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

Un click su un'email inviata dall'automazione stessa non la riavvia mai, così un'automazione impostata su `every_time`
non entra in loop sui link delle proprie email.

I link verso la tua istanza Notifuse non la avviano mai, e Notifuse confronta i nomi host a prescindere dalla porta. Quindi un
link al tuo blog servito sul tuo dominio personalizzato, o a un altro sito sullo stesso nome host dell'istanza, non avvia
nulla; vedi [Tracciamento delle email](https://www.notifuse.com/it/docs/features/email-tracking.md) per i link che non registrano alcun click.

> [!NOTE]
>
> La avviano solo i click che Notifuse può verificare: quelli sui link firmati delle email inviate dalla versione 42.2 in
> poi. I click fatti prima dell'aggiornamento alla 44.0 non vengono rieseguiti, ma un link cliccato prima dell'aggiornamento
> avvia l'automazione al click successivo. Vedi [cosa registra un click su un link](https://www.notifuse.com/it/docs/features/email-tracking.md#link-clicks).

> [!NOTE]
>
> Alcuni scanner di sicurezza delle email seguono tutti i link dei messaggi che consegnano. Notifuse esclude i click che
> riconosce come automatici; uno scanner che non riconosce avvia l'automazione come farebbe un contatto.

### Trigger condizionali

Aggiungi condizioni di segmento per filtrare quali contatti entrano nell'automazione. Ad esempio:

- Trigger su `list.subscribed`, ma solo per i contatti con `country = "US"`
- Trigger su `contact.updated`, ma solo quando `custom_number_1 > 100`

Le imposti nel pannello del trigger, in **Condizioni di ingresso**, oppure tramite API con il campo `conditions`.

![Il pannello del trigger di un'automazione: l'evento Lista / Iscritto sulla lista Newsletter, con una condizione di ingresso](https://www.notifuse.com/docs/assets/screenshots/automation_trigger.png)

Usano lo stesso editor di condizioni dei segmenti e del nodo Filtro.

Un contatto che non soddisfa le condizioni non viene mai iscritto, e questo è diverso da un nodo Filtro dopo il trigger.
Con **Una volta per contatto**, un contatto iscritto e poi mandato sul ramo "No" di un nodo Filtro ha usato la sua unica
iscrizione e non potrà entrare più tardi; con una condizione di ingresso l'iscrizione resta disponibile.

> [!NOTE]
>
> Una condizione che conta l'attività della timeline include l'evento che ha fatto scattare il trigger. "Ha aperto almeno
> 3 email" su un trigger `email.opened` iscrive quindi alla terza apertura, non alla quarta. Quando più eventi vengono
> registrati nella stessa operazione, come un'importazione in blocco, le condizioni di ciascuno li vedono tutti.

## Tipi di nodo

I nodi sono i passaggi di un flusso: nodi di azione (flusso lineare) o nodi di diramazione (più percorsi).

Ogni nodo accetta anche una **descrizione** facoltativa, una breve nota personale che imposti in cima al suo pannello di configurazione. Compare come titolo del nodo sul canvas e nel pannello, così capisci cosa fa una sequenza di nodi Email e Ritardo senza aprirli uno per uno. Non ha alcun effetto sull'esecuzione.

### Nodi di azione

| Nodo                    | Scopo                                          | Configurazione principale                                 |
| ----------------------- | ---------------------------------------------- | --------------------------------------------------------- |
| **Trigger**             | Punto di ingresso dell'automazione             | `event_kind` (obbligatorio), `frequency`, `conditions`    |
| **Ritardo**             | Sospende l'esecuzione per un certo tempo       | `duration` (1-365), `unit` (minutes/hours/days)           |
| **Email**               | Invia un template al contatto                  | `template_id` (obbligatorio)                              |
| **Aggiungi alla lista** | Iscrive il contatto a una lista                | `list_id`, `status` (`active` o `pending`)                |
| **Rimuovi dalla lista** | Disiscrive il contatto da una lista            | `list_id`                                                 |
| **Webhook**             | Invia una richiesta HTTP POST a un URL esterno | `url` (obbligatorio), `secret` (token Bearer facoltativo) |

### Nodi di diramazione

| Nodo                                  | Scopo                                               | Configurazione principale                              |
| ------------------------------------- | --------------------------------------------------- | ------------------------------------------------------ |
| **Filtro**                            | Smista in base a condizioni (Sì/No)                 | `conditions`, rami per chi corrisponde e per chi no    |
| **Test A/B**                          | Divide i contatti per un test                       | 2-4 `variants` con pesi (la somma deve fare 100%)      |
| **Diramazione per stato della lista** | Smista in base allo stato di iscrizione a una lista | `list_id`, 3 rami: non nella lista, attivo, non attivo |

### Dettagli dei nodi

#### Nodo Ritardo

Sospende il percorso del contatto per un tempo stabilito, poi passa al nodo successivo.

- **Durata**: da 1 a 365
- **Unità**: `minutes`, `hours` o `days`

**Esempio**: attendi 24 ore dopo l'iscrizione prima di inviare l'email di benvenuto.

#### Nodo Email

Invia un template email al contatto.

- **ID template**: obbligatorio. Scegli tra i template del workspace.
- **Oggetto e mittente**: sono sempre quelli del template. L'API accetta `subject_override` e `from_override` sul nodo, ma l'invio li ignora.

> [!WARNING]
>
> I nodi Email richiedono una lista sull'automazione, perché ogni contatto abbia un contesto di iscrizione.

Il template può usare l'evento che ha avviato il percorso come `{{ trigger_event }}`: le proprietà di un evento personalizzato (`{{ trigger_event.properties.items }}`), la lista o il segmento a cui il contatto si è unito, oppure il link cliccato. Vedi [Variabili delle automazioni](https://www.notifuse.com/it/docs/features/templates.md#automation-variables). I percorsi avviati prima della versione 44 non hanno `trigger_event`.

La lista dell'automazione non limita chi riceve le sue email. Un'email di marketing viene saltata solo per i contatti che su quella lista si sono disiscritti, hanno avuto un bounce o hanno segnalato spam; anche i contatti senza iscrizione alla lista ricevono l'email. Il suo link di disiscrizione li registra sulla lista come disiscritti, e le email di marketing successive dell'automazione li fanno uscire. Per scrivere solo agli iscritti della lista, metti una [Diramazione per stato della lista](#list-status-branch-node) prima del nodo Email e lascia scollegato il ramo **Non nella Lista**: così l'automazione termina per i contatti che non sono nella lista.

#### Nodo Filtro

Smista i contatti in base a condizioni di segmento. Chi soddisfa le condizioni prosegue sul ramo "Sì"; gli altri prendono il ramo "No" oppure escono.

Usa lo stesso editor di condizioni dei segmenti, con campi del contatto, eventi personalizzati e logica AND/OR annidata.

#### Nodo Test A/B

Divide i contatti in varianti per provare percorsi diversi.

- **Varianti**: da 2 a 4 varianti (A, B, C, D)
- **Pesi**: ogni variante ha un peso (1-100%) e la somma deve fare 100%
- **Deterministico**: lo stesso contatto sullo stesso nodo riceve sempre la stessa variante (usa l'hash FNV-32a)

**Esempio**: confronta due template email con una divisione 50/50.

#### Nodo Diramazione per stato della lista

Smista i contatti in base al loro stato di iscrizione a una lista specifica:

| Ramo                | Condizione                                                                  |
| ------------------- | --------------------------------------------------------------------------- |
| **Non nella Lista** | Il contatto non è iscritto alla lista                                       |
| **Attivo**          | Il contatto ha lo stato `active` nella lista                                |
| **Non Attivo**      | Il contatto ha lo stato `pending`, `unsubscribed`, `bounced` o `complained` |

#### Nodo Webhook

Invia i dati del contatto e dell'automazione a un URL esterno tramite HTTP POST.

- **URL**: obbligatorio. Deve iniziare con `http://` o `https://`
- **Segreto**: facoltativo. Viene inviato nell'header `Authorization: Bearer {secret}`

Il payload contiene i dati del contatto, il contesto dell'automazione e i metadati dell'esecuzione.

Il destinatario deve essere raggiungibile da internet. Notifuse rifiuta di connettersi a indirizzi privati, di loopback, link-local e riservati, compreso l'endpoint dei metadati dell'istanza cloud. Ripete il controllo a ogni redirect, quindi rifiuta anche un URL pubblico che reindirizza a uno interno. L'editor segnala un nodo webhook il cui URL indica un indirizzo di questo tipo, e l'automazione non si può salvare finché non lo correggi. Un passaggio rifiutato in questo modo viene ritentato come qualsiasi altro passaggio fallito, poi fa fallire il percorso del contatto.

> [!NOTE]
>
> Solo self-hosted: per inviare di proposito a un servizio della tua rete privata (un container sulla stessa rete Docker, uno strumento di automazione interno), imposta `WEBHOOK_DELIVERY_ALLOW_PRIVATE_HOSTS=true`. Non impostarla su un'installazione in cui può modificare le automazioni qualcuno a cui non affideresti la tua rete interna.

## Editor visuale del flusso

![L'editor delle automazioni, con aperto il pannello di un passaggio email](https://www.notifuse.com/docs/assets/screenshots/automation.png)

L'editor si apre a schermo intero sopra l'elenco e ha un suo link, che apre la stessa automazione per chi lo riceve da te. La colonna di sinistra contiene le impostazioni dell'automazione (la lista, la frequenza e [Uscita alla risposta](#exit-on-reply)) e i passaggi che puoi aggiungere, raggruppati in **Azioni** e **Logica**. Il canvas mostra il flusso, con i controlli dello zoom, una minimappa e **Riorganizza layout**.

### Costruire i flussi

1. **Inizia dal trigger**: ogni automazione comincia con un nodo trigger
2. **Aggiungi i nodi**: trascina un passaggio dalla colonna di sinistra sul canvas, oppure usa il "+" sotto un'uscita non collegata
3. **Collega i nodi**: trascina i collegamenti tra i nodi; ogni ramo di un filtro, di un test A/B o di uno stato della lista ha la sua etichetta sul collegamento
4. **Configura**: fai clic su un nodo per aprirne il pannello con la descrizione, le impostazioni e l'anteprima dell'email per un passaggio email. Per rimuovere un passaggio, seleziona la sua scheda sul canvas e fai clic sul pulsante cestino (**Elimina nodo**) accanto.

Un passaggio Email richiede prima la lista dell'automazione: sceglila nella colonna di sinistra.

### Salvataggio

**Crea** salva una nuova automazione, poi **Salva** registra le modifiche (⌘S o Ctrl+S); annulla e ripeti sono ⌘Z e ⇧⌘Z. La barra mostra **Modifiche non salvate** finché non salvi, e **Attiva** aspetta che siano salvate. Se chiudi l'editor o lasci la pagina con modifiche non salvate, ti viene chiesta conferma.

Un'automazione attiva si apre in sola lettura: mettila in pausa per modificarla. Se qualcun altro ha modificato l'automazione mentre la stavi modificando, il salvataggio viene rifiutato e l'editor propone di ricaricarla.

## Uscita alla risposta

Quando un contatto risponde a un'email di un'automazione, di solito vuoi fermare il resto della sequenza invece di mandare le email programmate a chi ha già risposto. **Uscita alla risposta** fa proprio questo.

### Attivarla

Attiva **Uscita alla risposta** nelle impostazioni dell'automazione, nella colonna di sinistra dell'editor, quando la crei o la modifichi. Da quel momento una vera risposta a qualsiasi email inviata dall'automazione fa uscire il contatto dal percorso, con il motivo di uscita `replied`.

![Le impostazioni dell'automazione: lista, frequenza e l'opzione Uscita alla risposta attivata](https://www.notifuse.com/docs/assets/screenshots/automation_exit_on_reply.png)

> [!WARNING]
>
> **Uscita alla risposta richiede la configurazione della posta in entrata presso il tuo provider email.** È la funzione di parsing della posta in entrata del provider a riportare le risposte a Notifuse. Oggi è supportata per Mailgun (vedi [Mailgun → Risposte in entrata](https://www.notifuse.com/it/docs/integrations/mailgun.md#inbound-replies-stop-on-reply)) e Amazon SES (vedi [Amazon SES → Risposte in entrata](https://www.notifuse.com/it/docs/integrations/amazon-ses.md#inbound-replies-stop-on-reply)), ciascuno con una configurazione da fare una sola volta. Con gli altri provider l'opzione non ha effetto finché la ricezione della posta in entrata non è configurata.

### Come vengono associate le risposte

Notifuse associa una risposta all'email esatta a cui risponde confrontando i suoi header di threading standard (`In-Reply-To` / `References`) con il `Message-ID` impostato all'invio. Di conseguenza:

- Il contatto esce solo dall'automazione a cui ha risposto. Un contatto iscritto a più automazioni che risponde a una resta nelle altre.
- Le risposte che non corrispondono a nessun invio noto vengono ignorate, e nessun percorso termina.

### Cosa conta come risposta

Non tutti i messaggi in entrata sono trattati come risposte:

| Tipo di messaggio                         | Effetto                                                           |
| ----------------------------------------- | ----------------------------------------------------------------- |
| Una vera risposta di una persona          | Fa uscire dal percorso (quando **Uscita alla risposta** è attiva) |
| Risposta automatica di assenza o ferie    | Registrata nella timeline, ma non fa mai uscire                   |
| Bounce o rapporto sullo stato di consegna | Scartato                                                          |

Le risposte associate compaiono nella timeline del contatto come `email.replied` (o `email.auto_reply` per le risposte automatiche).

> [!NOTE]
>
> L'interruzione vale anche quando l'email successiva è a metà di un ritardo o già in coda per l'invio, quindi un contatto che risponde non riceve l'email programmata dopo.

## Percorsi dei contatti

L'avanzamento di ogni contatto in un'automazione viene seguito come un "percorso", con la cronologia completa dell'esecuzione.

### Stati del percorso

| Stato       | Descrizione                                                       |
| ----------- | ----------------------------------------------------------------- |
| `active`    | Sta avanzando nell'automazione                                    |
| `completed` | Ha raggiunto un nodo finale (ha concluso il flusso)               |
| `exited`    | È uscito prima per un filtro, una disiscrizione o un'eliminazione |
| `failed`    | Errore dopo il numero massimo di tentativi                        |

### Motivi di uscita

Quando un contatto esce prima della fine, il motivo viene registrato:

| Motivo              | Descrizione                                                                                                              |
| ------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| `completed`         | Conclusione normale su un nodo finale                                                                                    |
| `filter_rejected`   | Non viene mai registrato. Un contatto che non supera un nodo Filtro senza ramo "No" termina il percorso come `completed` |
| `unsubscribed`      | Il contatto si è disiscritto dalla lista dell'automazione                                                                |
| `replied`           | Il contatto ha risposto a una delle email dell'automazione (richiede **Uscita alla risposta**)                           |
| `automation_paused` | L'automazione è stata messa in pausa mentre il contatto era attivo                                                       |
| `manual`            | Rimosso manualmente da un admin                                                                                          |

### Eventi della timeline

L'attività delle automazioni viene registrata nella timeline del contatto:

- `automation.start`: il contatto è stato iscritto all'automazione
- `automation.end`: il percorso del contatto si è concluso, è uscito o è fallito

## Motore di esecuzione

Le automazioni girano su uno scheduler in background che fa avanzare i contatti nei loro flussi.

### Come funziona

1. **Polling**: lo scheduler gira ogni 10 secondi
2. **Elaborazione a lotti**: i contatti vengono elaborati a lotti per efficienza
3. **Distribuzione equa**: round-robin tra i workspace

### Elaborazione dei nodi

- **Esecuzione di più nodi**: fino a 10 nodi elaborati per ciclo (evita i loop senza fine)
- **Ripristino dopo un crash**: lo stato viene salvato dopo ogni nodo
- **Gestione dei ritardi**: i nodi Ritardo programmano l'esecuzione futura all'orario `scheduled_at`

### Logica dei tentativi

Quando l'esecuzione di un nodo fallisce:

1. Il contatore dei tentativi aumenta
2. Un nuovo tentativo viene programmato con backoff esponenziale: 2 minuti dopo il primo errore, poi 4 minuti
3. Superato il numero massimo di tentativi (predefinito: 3), il percorso viene segnato come `failed`

## Statistiche

### Statistiche dell'automazione

L'[elenco delle automazioni](#the-automations-list) mostra per ciascuna i percorsi dalla sua creazione:

| Statistica            | Descrizione                                                                                 |
| --------------------- | ------------------------------------------------------------------------------------------- |
| **In corso**          | Contatti che stanno seguendo il percorso adesso                                             |
| **Entrati**           | Tutti i percorsi avviati, qualunque sia il loro stato                                       |
| **Completato**        | Quota dei percorsi conclusi che è arrivata alla fine                                        |
| **Uscito**            | Quota dei percorsi conclusi che è uscita prima (un filtro, una risposta, una disiscrizione) |
| **Fallito**           | Percorsi falliti dopo i tentativi                                                           |
| **Tasso di apertura** | Aperture sulle email con aperture tracciate, negli ultimi 30 giorni                         |

Una bozza in cui non è entrato nessun contatto mostra "—". L'API restituisce gli stessi conteggi con `automations.list` e `with_journey_counts=true`.

### Statistiche dei nodi

![L'editor con Statistiche attivo, che mostra i risultati di ogni passaggio sulla sua scheda](https://www.notifuse.com/docs/assets/screenshots/automation_stats.png)

Attiva l'interruttore **Statistiche** nell'editor per leggere i risultati di ogni passaggio, su **7 g**, **30 g** (oggi compreso, nel fuso orario del workspace) o **Sempre**. Ogni scheda mostra il suo dato principale (i transiti sul trigger, dove un percorso viene contato ogni volta che un loop lo riporta indietro; gli invii con aperture e click; le attese; i controlli; le aggiunte o rimozioni; le chiamate), con i percorsi falliti, in attesa di un nuovo tentativo o ancora in corso su quel passaggio, e le email saltate. Ogni ramo di una divisione mostra la quota dei transiti del passaggio che l'ha preso.

Il pannello di un passaggio dà il dettaglio:

- **Raggiunti**: quante volte i percorsi hanno raggiunto il passaggio. Un percorso che torna indietro conta a ogni giro, e un nuovo tentativo conta come lo stesso transito. Su un periodo, un transito è datato al suo tentativo riuscito, altrimenti all'ultimo tentativo. Un transito il cui nuovo tentativo riesce in un periodo successivo si sposta in quel periodo, quindi il valore Raggiunti di un periodo precedente può scendere e conservare solo i tentativi falliti
- **Completato**: esecuzioni concluse
- **In corso**, **In attesa** e **Nuovo tentativo**: percorsi che sono sul passaggio adesso, qualunque sia il periodo
- **Fallito**: percorsi falliti sul passaggio
- **Errori**: esecuzioni che hanno registrato un errore, come un passaggio su una lista che è stata eliminata

![I risultati di un passaggio email negli ultimi 30 giorni: inviate, consegnate, aperte e cliccate, poi raggiunti, completati, in corso e falliti](https://www.notifuse.com/docs/assets/screenshots/automation_step_stats.png)

Un passaggio email aggiunge le sue email: inviate, consegnate, aperte e cliccate, poi quelle fallite, respinte o con disiscrizione, quelle in coda e quelle non inviate, con **Visualizza messaggi** per aprirle nel log dei messaggi. SMTP non segnala alcuna consegna, quindi quella riga mostra "—". I dati delle email richiedono il permesso di lettura su **Cronologia Messaggi**.

Un passaggio aggiunto dopo l'ultimo salvataggio non ha nulla da contare finché non salvi. L'API restituisce gli stessi dati con `automations.nodeStats`.

## Permessi

Le automazioni seguono il permesso **Automazioni**: **lettura** apre le automazioni con i loro grafi di nodi completi, le statistiche di ogni passaggio (`automations.nodeStats`) e il percorso di un singolo contatto specificato; **scrittura** le crea, le modifica e le elimina, e le attiva o le mette in pausa. Senza scrittura, l'editor si apre in sola lettura. I dati email delle statistiche e il tasso di apertura richiedono anche la lettura su **Cronologia Messaggi**, e l'anteprima dell'email richiede la lettura su **Template**.

> [!WARNING]
>
> **La scrittura su Automazioni va oltre la sua area.** Un nodo webhook invia il record completo del contatto
> a qualsiasi URL indicato dall'automazione, e i permessi non vengono controllati mentre un'automazione è in esecuzione, quindi questo
> permesso è una lettura indiretta dei contatti che la lettura su Contatti non può limitare. Gli altri nodi aggiungono
> contatti alle liste, li rimuovono e inviano email, senza alcun permesso su Liste o Transazionale.
>
> **La lettura su Automazioni espone dei segreti.** La configurazione dei nodi che restituisce include l'URL di ogni
> nodo webhook e il segreto bearer salvato su di esso.

Vedi [Admin e API Key](https://www.notifuse.com/it/docs/features/admins-api-keys.md).

## Buone pratiche

1. **Comincia semplice**: parti da trigger → ritardo → email, poi aggiungi complessità
2. **Usa i filtri con criterio**: segmenta i contatti dentro i flussi per messaggi mirati
3. **Prova prima di attivare**: usa una piccola lista di prova prima di attivare l'automazione in produzione
4. **Controlla le statistiche**: rivedi spesso i conteggi di iscritti, completati e falliti
5. **Consulta i log di esecuzione**: individua i problemi con la cronologia del percorso del contatto
6. **Scegli nomi chiari**: dai alle automazioni nomi descrittivi per riconoscerle facilmente
7. **Pensa alla frequenza**: scegli tra `once` e `every_time` in base al tuo caso d'uso
