# Automazioni API

> Crea flussi con trigger e passaggi, eseguili e analizza le loro esecuzioni.

URL di base: `https://api.emailit.com/v2`. Autenticati con `Authorization: Bearer <API key>`.

## Crea un’automazione — POST /automations

> Crea un’automazione in bozza da un grafo di passaggi trigger e azione, ad esempio un’email di benvenuto inviata quando un contatto entra in una lista.

# Crea un’automazione

Crea un’automazione nello stato `draft` a partire da un grafo di passaggi e collegamenti. Richiede una chiave API con il permesso `full`. Le automazioni sono in beta.

L’automazione non fa nulla finché non la [avvii](/it/docs/api-reference/automations/start/). Ogni esecuzione costa 3 crediti all’avvio, e ogni email inviata da `send_email` o `forward_email` costa 1 credito in più. In un workspace non verificato, queste azioni possono inviare solo agli indirizzi email degli account dei membri del workspace.

`POST /automations`

## Parametri del corpo

- `context` (string, obbligatorio): Di cosa tratta ogni esecuzione: `contact`, `email` o `event`. Il contesto stabilisce quali trigger e azioni puoi usare e non si può cambiare in seguito. Vedi [Contesti](#contexts).

- `name` (string, obbligatorio): Il nome dell’automazione, fino a 191 caratteri.

- `description` (string | null): Descrizione facoltativa.

- `settings` (object): Le regole delle esecuzioni. Vedi [Impostazioni](#settings).

- `steps` (object[], obbligatorio): I passaggi trigger e azione, con almeno un trigger. Vedi [Passaggi](#steps).

- `connections` (object[], obbligatorio): I collegamenti tra i passaggi. Passa `[]` per un grafo con un solo trigger. Vedi [Collegamenti](#connections).

### Impostazioni

- `on_step_failure` (string): `stop` contrassegna l’esecuzione come `failed` quando un passaggio non riesce. `skip` registra il passaggio non riuscito e lascia terminare il resto dell’esecuzione.

- `allow_reentry` (boolean): `false` ignora un trigger quando lo stesso contatto (o la stessa email) ha già un’esecuzione in corso in questa automazione.

- `max_concurrent_runs` (integer): Numero massimo di esecuzioni contemporanee nello stato `running`. `0` significa nessun limite.

- `cooldown_seconds` (integer): Ignora un trigger quando lo stesso contatto (o la stessa email) ha avviato un’esecuzione in questa automazione entro questo numero di secondi.

### Passaggi

- `key` (string, obbligatorio): Il tuo identificatore del passaggio, univoco all’interno dell’automazione, ad esempio `welcome_email`. I collegamenti, le [statistiche dei passaggi](/it/docs/api-reference/automations/step-stats/) e gli aggiornamenti fanno riferimento ai passaggi tramite la chiave.

- `type` (string, obbligatorio): `trigger` o `action`.

- `trigger` (string): Il nome del trigger, obbligatorio quando `type` è `trigger`. Vedi [Trigger](#triggers).

- `action` (string): Il nome dell’azione, obbligatorio quando `type` è `action`. Vedi [Azioni](#actions).

- `config` (object): Le impostazioni del trigger o dell’azione.

### Collegamenti

- `from` (string, obbligatorio): La chiave del passaggio da cui parte il collegamento.

- `to` (string, obbligatorio): La chiave del passaggio successivo.

- `branch` (string): Quale esito del passaggio `from` segue questo collegamento. I passaggi `condition` usano `yes` e `no`; i passaggi `experiment` usano le chiavi delle varianti. Tutti gli altri passaggi usano `default`.

## Contesti

| Contesto | Un’esecuzione riguarda | Trigger | Regole |
| --- | --- | --- | --- |
| `contact` | Un contatto. `send_email` invia a quel contatto. | `contact.*`, `system.*` | Uno o più trigger. Devono essere tutti collegati alla stessa prima azione. |
| `email` | Un’email (inviata o ricevuta). | `email.*`, `system.*` | Uno o più trigger. Devono essere tutti collegati alla stessa prima azione. |
| `event` | Solo il payload del trigger. | `event.*`, `system.*` | Esattamente un trigger. |

Ogni azione deve essere raggiungibile da un trigger. Un’esecuzione parte dall’azione collegata al trigger che è scattato e segue i collegamenti:

- `condition` segue solo il collegamento il cui `branch` è `yes` o `no`, in base al risultato.
- `experiment` segue i collegamenti della variante scelta. Quando quel percorso finisce, l’esecuzione prosegue sui collegamenti `default` del passaggio experiment.
- `wait` ritarda il passaggio successivo.
- Tutte le altre azioni seguono i propri collegamenti `default`. Un passaggio con più collegamenti in uscita li esegue tutti.

Un’esecuzione è `completed` quando non restano passaggi, `failed` quando un passaggio non riesce (con `on_step_failure: "stop"`) e `canceled` quando [interrompi l’automazione](/it/docs/api-reference/automations/stop/).

## Trigger

| Trigger | Contesto | Quando scatta |
| --- | --- | --- |
| `contact.added_to_audience` | contact | Un contatto si iscrive a una lista, reiscrizioni comprese. |
| `contact.removed_from_audience` | contact | Un iscritto viene eliminato da una lista. |
| `contact.updated` | contact | Un contatto viene aggiornato. |
| `contact.loaded_email` | contact | Un destinatario che è un contatto del workspace apre un’email. |
| `contact.clicked_in_email` | contact | Un destinatario che è un contatto del workspace fa clic su un link tracciato. |
| `contact.date_anniversary` | contact | Ogni giorno alle 00:00 UTC, per i contatti il cui campo personalizzato di tipo data (`YYYY-MM-DD`) ha il mese e il giorno di oggi. |
| `contact.on_date` | contact | Ogni giorno alle 00:00 UTC, per i contatti il cui campo personalizzato di tipo data corrisponde alla data di oggi. |
| `contact.visits_url`, `contact.on_purchase`, `contact.on_event` | contact | Accettati, ma per ora Emailit non li fa scattare. |
| `email.received` | email | Arriva un’email in entrata. |
| `email.delivered`, `email.bounced`, `email.complained`, `email.loaded`, `email.clicked`, `email.failed`, `email.suppressed`, `email.canceled` | email | Si verifica l’evento email con lo stesso nome. |
| `event.<name>` | event | Qualsiasi nome che inizia con `event.`. Per ora Emailit non genera eventi `event.*`; avvia le automazioni con contesto event tramite `system.manual`. |
| `system.manual` | tutti | Chiami [Avvia un’esecuzione](/it/docs/api-reference/automations/trigger/). |
| `system.schedule` | tutti | Accettato, ma per ora Emailit non fa scattare i trigger programmati. |

Campi `config` dei trigger:

- `audience_id` (string): Per `contact.added_to_audience` e `contact.removed_from_audience`: scatta solo per questa lista (`aud_…`).

- `date_field` (string): Per `contact.date_anniversary` e `contact.on_date`: la chiave del [campo personalizzato](/it/docs/contacts/custom-fields/) che contiene la data, ad esempio `birthday`.

- `filter` (object): Scatta solo quando l’evento corrisponde: `{ "match": "all", "rules": [{ "field": "subject", "operator": "contains", "value": "Invoice" }] }`. `match` è `all` (predefinito) o `any`. `field` è un percorso con punti all’interno dell’`object` dell’evento, ad esempio `to` o `email.subject`; un prefisso `payload.` iniziale viene ignorato. Operatori: `equals`, `not_equals`, `contains`, `not_contains`, `starts_with`, `ends_with`, `greater_than`, `less_than`, `in`, `not_in`, `is_set`, `is_not_set`. Tutti gli operatori tranne `is_set` e `is_not_set` richiedono un `value`; `in` e `not_in` accettano un array.

## Azioni

| Azione | Contesto | Configurazione |
| --- | --- | --- |
| `send_email` | tutti | `type` (obbligatorio, `template`), `template_id` (obbligatorio: un ID `tem_` o l’alias di un template pubblicato), `from`, `subject`, `reply_to`, `to` |
| `forward_email` | email, event | `to` (obbligatorio), `from`, `subject`, `email_id` |
| `wait` | tutti | `seconds` (obbligatorio, da 0 a 2.592.000, cioè 30 giorni) |
| `condition` | tutti | `filter` (obbligatorio, vedi sotto) |
| `experiment` | tutti | `variants` (obbligatorio), `control` |
| `call_webhook` | tutti | `url` (obbligatorio), `method`, `headers`, `body` |
| `run_automation` | tutti | `automation_id` (obbligatorio) |
| `end` | tutti | Nessuno |
| `add_to_audience` | contact | `audience_id` (obbligatorio) |
| `remove_from_audience` | contact | `audience_id` (obbligatorio) |
| `edit_contact` | contact | `fields` (obbligatorio) |
| `add_to_suppressions` | email, event | `type`, `reason`, `email` |
| `remove_from_suppressions` | email, event | `email` |
| `create_contact` | email, event | `email`, `first_name`, `audience_id` |

- **`send_email`** invia il template. Per impostazione predefinita `from` è il mittente del template, e deve appartenere a un dominio di invio verificato. `subject` sostituisce l’oggetto del template. `reply_to` è un indirizzo o un array di indirizzi. Nel contesto `contact` l’email va al contatto dell’esecuzione; nei contesti `email` ed `event` imposta `to`.
- **`forward_email`** inoltra l’email dell’esecuzione (o l’email indicata in `email_id`) a `to`. Per impostazione predefinita `from` è il mittente originale e `subject` è `Fwd: <original subject>`.
- **`condition`** accetta `{ "match": "all" | "any", "rules": [...] }` con gli stessi operatori dei filtri dei trigger. I campi senza prefisso si riferiscono al contatto dell’esecuzione (`first_name`, `custom_fields.plan`) o all’email (`rcpt_to`, `subject`); per essere espliciti, aggiungi al campo il prefisso `contact.`, `email.`, `payload.` o `meta.`. Il passaggio prosegue su `yes` o `no`.
- **`experiment`** sceglie a caso, in base al peso, una delle `variants` (compreso `control`), ciascuna nella forma `{ "key": "a", "weight": 50 }`, e prosegue sulla diramazione che porta il nome della chiave scelta.
- **`call_webhook`** invia una richiesta HTTP (metodo predefinito `POST`, `Content-Type` JSON) e registra la classe dello stato (`2xx`, `4xx`, `5xx`) oppure `timeout` o `network_error`. Una risposta diversa da 2xx non fa fallire il passaggio.
- **`run_automation`** avvia un’esecuzione di un’altra automazione attiva con il payload di questa esecuzione. L’esecuzione corrente prosegue.
- **`edit_contact`** accetta `fields: [{ "key": "first_name", "value": "Ada" }]`. Le chiavi `email`, `first_name`, `last_name` e `unsubscribed` aggiornano il contatto; qualsiasi altra chiave imposta un campo personalizzato.
- **`add_to_suppressions`** sopprime l’indirizzo dell’esecuzione (`type` predefinito `recipient`, `reason` predefinito `automation`). **`remove_from_suppressions`** lo rimuove. Nel contesto `event`, passa `email`.
- **`create_contact`** crea il contatto (o trova quello esistente) e facoltativamente lo iscrive a `audience_id`. Nel contesto `email`, per impostazione predefinita `email` è il destinatario dell’email.

I valori stringa nella configurazione di qualsiasi azione possono usare segnaposto che Emailit compila quando il passaggio viene eseguito: `{{contact.email}}`, `{{email.mail_from}}`, `{{payload.object.subject}}` o `{{meta.source_event_id}}`, ad esempio `"to": "{{email.mail_from}}"`. I template inviati da `send_email` elaborano anche direttamente i campi del contatto, come `{{ first_name }}`.

## Restituisce

Restituisce `201 Created` con l’automazione in `data`, compresi l’ID di ogni passaggio (`aus_…`) e i collegamenti. `status` è `draft`.

La creazione controlla la struttura del grafo: nomi dei trigger e delle azioni validi per il contesto, chiavi univoche, collegamenti validi, raggiungibilità, e che ogni indirizzo `from` di `send_email` usi un dominio di invio verificato. Non controlla che la configurazione di ogni azione sia completa; questo controllo lo fa [Aggiorna un’automazione](/it/docs/api-reference/automations/update/). In caso di errore restituisce `400` con `errors` organizzato per percorso del campo.

**Richiesta** `POST /automations`

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/automations \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Welcome series",
    "context": "contact",
    "description": "Welcome new subscribers, then nudge free users a day later.",
    "settings": { "allow_reentry": false },
    "steps": [
      {
        "key": "joined",
        "type": "trigger",
        "trigger": "contact.added_to_audience",
        "config": { "audience_id": "aud_3Cz7WJ9GpvD7P0PQez50xOmkZSV" }
      },
      {
        "key": "welcome_email",
        "type": "action",
        "action": "send_email",
        "config": { "type": "template", "template_id": "welcome", "from": "Acme <hello@acme.com>" }
      },
      {
        "key": "wait_1_day",
        "type": "action",
        "action": "wait",
        "config": { "seconds": 86400 }
      },
      {
        "key": "is_free_user",
        "type": "action",
        "action": "condition",
        "config": {
          "filter": {
            "match": "all",
            "rules": [{ "field": "custom_fields.plan", "operator": "is_not_set" }]
          }
        }
      },
      {
        "key": "upgrade_tips",
        "type": "action",
        "action": "send_email",
        "config": { "type": "template", "template_id": "getting-started-tips" }
      },
      { "key": "done", "type": "action", "action": "end" }
    ],
    "connections": [
      { "from": "joined", "to": "welcome_email" },
      { "from": "welcome_email", "to": "wait_1_day" },
      { "from": "wait_1_day", "to": "is_free_user" },
      { "from": "is_free_user", "to": "upgrade_tips", "branch": "yes" },
      { "from": "is_free_user", "to": "done", "branch": "no" }
    ]
  }'
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/automations', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.EMAILIT_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    name: 'Welcome series',
    context: 'contact',
    description: 'Welcome new subscribers, then nudge free users a day later.',
    settings: { allow_reentry: false },
    steps: [
      {
        key: 'joined',
        type: 'trigger',
        trigger: 'contact.added_to_audience',
        config: { audience_id: 'aud_3Cz7WJ9GpvD7P0PQez50xOmkZSV' },
      },
      {
        key: 'welcome_email',
        type: 'action',
        action: 'send_email',
        config: { type: 'template', template_id: 'welcome', from: 'Acme <hello@acme.com>' },
      },
      { key: 'wait_1_day', type: 'action', action: 'wait', config: { seconds: 86400 } },
      {
        key: 'is_free_user',
        type: 'action',
        action: 'condition',
        config: {
          filter: { match: 'all', rules: [{ field: 'custom_fields.plan', operator: 'is_not_set' }] },
        },
      },
      {
        key: 'upgrade_tips',
        type: 'action',
        action: 'send_email',
        config: { type: 'template', template_id: 'getting-started-tips' },
      },
      { key: 'done', type: 'action', action: 'end' },
    ],
    connections: [
      { from: 'joined', to: 'welcome_email' },
      { from: 'welcome_email', to: 'wait_1_day' },
      { from: 'wait_1_day', to: 'is_free_user' },
      { from: 'is_free_user', to: 'upgrade_tips', branch: 'yes' },
      { from: 'is_free_user', to: 'done', branch: 'no' },
    ],
  }),
});
const { data: automation } = await res.json();
```

**Python**

```python
import os, requests

r = requests.post(
    "https://api.emailit.com/v2/automations",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    json={
        "name": "Welcome series",
        "context": "contact",
        "description": "Welcome new subscribers, then nudge free users a day later.",
        "settings": {"allow_reentry": False},
        "steps": [
            {
                "key": "joined",
                "type": "trigger",
                "trigger": "contact.added_to_audience",
                "config": {"audience_id": "aud_3Cz7WJ9GpvD7P0PQez50xOmkZSV"},
            },
            {
                "key": "welcome_email",
                "type": "action",
                "action": "send_email",
                "config": {"type": "template", "template_id": "welcome", "from": "Acme <hello@acme.com>"},
            },
            {"key": "wait_1_day", "type": "action", "action": "wait", "config": {"seconds": 86400}},
            {
                "key": "is_free_user",
                "type": "action",
                "action": "condition",
                "config": {
                    "filter": {
                        "match": "all",
                        "rules": [{"field": "custom_fields.plan", "operator": "is_not_set"}],
                    }
                },
            },
            {
                "key": "upgrade_tips",
                "type": "action",
                "action": "send_email",
                "config": {"type": "template", "template_id": "getting-started-tips"},
            },
            {"key": "done", "type": "action", "action": "end"},
        ],
        "connections": [
            {"from": "joined", "to": "welcome_email"},
            {"from": "welcome_email", "to": "wait_1_day"},
            {"from": "wait_1_day", "to": "is_free_user"},
            {"from": "is_free_user", "to": "upgrade_tips", "branch": "yes"},
            {"from": "is_free_user", "to": "done", "branch": "no"},
        ],
    },
)
automation = r.json()["data"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->post('automations', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'json' => [
        'name' => 'Welcome series',
        'context' => 'contact',
        'description' => 'Welcome new subscribers, then nudge free users a day later.',
        'settings' => ['allow_reentry' => false],
        'steps' => [
            [
                'key' => 'joined',
                'type' => 'trigger',
                'trigger' => 'contact.added_to_audience',
                'config' => ['audience_id' => 'aud_3Cz7WJ9GpvD7P0PQez50xOmkZSV'],
            ],
            [
                'key' => 'welcome_email',
                'type' => 'action',
                'action' => 'send_email',
                'config' => ['type' => 'template', 'template_id' => 'welcome', 'from' => 'Acme <hello@acme.com>'],
            ],
            ['key' => 'wait_1_day', 'type' => 'action', 'action' => 'wait', 'config' => ['seconds' => 86400]],
            [
                'key' => 'is_free_user',
                'type' => 'action',
                'action' => 'condition',
                'config' => [
                    'filter' => [
                        'match' => 'all',
                        'rules' => [['field' => 'custom_fields.plan', 'operator' => 'is_not_set']],
                    ],
                ],
            ],
            [
                'key' => 'upgrade_tips',
                'type' => 'action',
                'action' => 'send_email',
                'config' => ['type' => 'template', 'template_id' => 'getting-started-tips'],
            ],
            ['key' => 'done', 'type' => 'action', 'action' => 'end'],
        ],
        'connections' => [
            ['from' => 'joined', 'to' => 'welcome_email'],
            ['from' => 'welcome_email', 'to' => 'wait_1_day'],
            ['from' => 'wait_1_day', 'to' => 'is_free_user'],
            ['from' => 'is_free_user', 'to' => 'upgrade_tips', 'branch' => 'yes'],
            ['from' => 'is_free_user', 'to' => 'done', 'branch' => 'no'],
        ],
    ],
]);
$automation = json_decode($response->getBody(), true)['data'];
```

**201**

```json
{
  "data": {
    "id": "aut_3xqC9YD79FZZA36uTekWTBO1ghe",
    "context": "contact",
    "name": "Welcome series",
    "description": "Welcome new subscribers, then nudge free users a day later.",
    "status": "draft",
    "settings": { "allow_reentry": false },
    "last_triggered_at": null,
    "published_at": null,
    "created_at": "2026-10-01T09:41:05.318274+00:00",
    "updated_at": "2026-10-01T09:41:05.318274+00:00",
    "steps": [
      {
        "id": "aus_3ZqpuxjmL1szZ8og6uGL1mT6QEJ",
        "key": "joined",
        "type": "trigger",
        "trigger": "contact.added_to_audience",
        "action": null,
        "config": { "audience_id": "aud_3Cz7WJ9GpvD7P0PQez50xOmkZSV" }
      },
      {
        "id": "aus_3V5TZIXXak1SSmGcOmzPOeFaguQ",
        "key": "welcome_email",
        "type": "action",
        "trigger": null,
        "action": "send_email",
        "config": { "type": "template", "template_id": "welcome", "from": "Acme <hello@acme.com>" }
      },
      {
        "id": "aus_3vM0ORwEXCQcyS7rylfQBQEXjVk",
        "key": "wait_1_day",
        "type": "action",
        "trigger": null,
        "action": "wait",
        "config": { "seconds": 86400 }
      },
      {
        "id": "aus_3HOgOzxaXBgVRpLFtpvJNo4vd5c",
        "key": "is_free_user",
        "type": "action",
        "trigger": null,
        "action": "condition",
        "config": {
          "filter": {
            "match": "all",
            "rules": [{ "field": "custom_fields.plan", "operator": "is_not_set" }]
          }
        }
      },
      {
        "id": "aus_3gCI5SWMPFVhOSawR6nz8sF55wp",
        "key": "upgrade_tips",
        "type": "action",
        "trigger": null,
        "action": "send_email",
        "config": { "type": "template", "template_id": "getting-started-tips" }
      },
      {
        "id": "aus_3Pq7Wd2LxN8cVt5RmK0sHy4BfJe",
        "key": "done",
        "type": "action",
        "trigger": null,
        "action": "end",
        "config": {}
      }
    ],
    "connections": [
      { "from": "joined", "to": "welcome_email", "branch": "default" },
      { "from": "welcome_email", "to": "wait_1_day", "branch": "default" },
      { "from": "wait_1_day", "to": "is_free_user", "branch": "default" },
      { "from": "is_free_user", "to": "upgrade_tips", "branch": "yes" },
      { "from": "is_free_user", "to": "done", "branch": "no" }
    ]
  },
  "message": "Automation was successfully created.",
  "notify": true
}
```

**400**

```json
{
  "message": "Validation failed.",
  "errors": {
    "steps.1.action": ["Action \"forward_email\" is not allowed for context \"contact\"."],
    "steps": ["Action step \"upgrade_tips\" is not reachable from any trigger."]
  }
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/automations/create/

## Recupera un’automazione — GET /automations/{id}

> Recupera un’automazione con lo stato, le impostazioni, i passaggi trigger e azione e i collegamenti tra di essi.

# Recupera un’automazione

Recupera un’automazione con il suo grafo completo. Richiede una chiave API con il permesso `full`.

`GET /automations/{id}`

## Parametri di percorso

- `id` (string, obbligatorio): L’ID dell’automazione (`aut_…`).

## Restituisce

Restituisce l’automazione in `data`.

- `id` (string): L’ID dell’automazione, con prefisso `aut_`.

- `context` (string): `contact`, `email` o `event`.

- `name` (string): Il nome dell’automazione.

- `description` (string | null): Descrizione facoltativa.

- `status` (string): `draft`, `running`, `paused`, `stopped` o `archived`.

- `settings` (object): Le regole delle esecuzioni: `on_step_failure`, `allow_reentry`, `max_concurrent_runs`, `cooldown_seconds`. Vuoto se non ne hai impostata nessuna.

- `last_triggered_at` (string | null): Quando l’automazione ha avviato l’ultima esecuzione.

- `published_at` (string | null): Quando l’automazione è stata avviata per la prima volta.

- `steps` (object[]): Per ogni passaggio, `id` (`aus_…`), `key`, `type`, `trigger`, `action` e `config`. I dettagli delle esecuzioni fanno riferimento ai passaggi tramite `id`; le statistiche tramite `key`.

- `connections` (object[]): Per ogni collegamento, le chiavi dei passaggi `from` e `to` e il suo `branch`.

Per il significato di ogni trigger, azione e impostazione, vedi [Crea un’automazione](/it/docs/api-reference/automations/create/). Restituisce `404` se l’automazione non esiste o è stata eliminata.

**Richiesta** `GET /automations/{id}`

**cURL**

```bash
curl https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe', {
  headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` },
});
const { data: automation } = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
)
automation = r.json()["data"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->get('automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
]);
$automation = json_decode($response->getBody(), true)['data'];
```

**200**

```json
{
  "data": {
    "id": "aut_3xqC9YD79FZZA36uTekWTBO1ghe",
    "context": "contact",
    "name": "Welcome series",
    "description": "Welcome new subscribers, then nudge free users a day later.",
    "status": "running",
    "settings": { "allow_reentry": false },
    "last_triggered_at": "2026-10-03T14:12:40.551870+00:00",
    "published_at": "2026-10-01T10:00:02.204118+00:00",
    "created_at": "2026-10-01T09:41:05.318274+00:00",
    "updated_at": "2026-10-03T14:12:40.551870+00:00",
    "steps": [
      {
        "id": "aus_3ZqpuxjmL1szZ8og6uGL1mT6QEJ",
        "key": "joined",
        "type": "trigger",
        "trigger": "contact.added_to_audience",
        "action": null,
        "config": { "audience_id": "aud_3Cz7WJ9GpvD7P0PQez50xOmkZSV" }
      },
      {
        "id": "aus_3V5TZIXXak1SSmGcOmzPOeFaguQ",
        "key": "welcome_email",
        "type": "action",
        "trigger": null,
        "action": "send_email",
        "config": { "type": "template", "template_id": "welcome", "from": "Acme <hello@acme.com>" }
      },
      {
        "id": "aus_3vM0ORwEXCQcyS7rylfQBQEXjVk",
        "key": "wait_1_day",
        "type": "action",
        "trigger": null,
        "action": "wait",
        "config": { "seconds": 86400 }
      }
    ],
    "connections": [
      { "from": "joined", "to": "welcome_email", "branch": "default" },
      { "from": "welcome_email", "to": "wait_1_day", "branch": "default" }
    ]
  }
}
```

**404**

```json
{
  "message": "Automation not found."
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/automations/get/

## Aggiorna un’automazione — POST /automations/{id}

> Rinomina un’automazione, cambia le sue impostazioni o sostituisci il suo grafo di passaggi e collegamenti, con la convalida completa.

# Aggiorna un’automazione

Aggiorna il nome, la descrizione, le impostazioni o il grafo di un’automazione. Richiede una chiave API con il permesso `full`. Il contesto non si può cambiare.

Per cambiare il grafo, invia insieme `steps` e `connections`: sostituiscono il grafo attuale. I passaggi la cui `key` esiste già mantengono l’ID e la cronologia delle esecuzioni, i passaggi che ometti vengono eliminati e le nuove chiavi vengono aggiunte. A differenza della creazione, l’aggiornamento convalida anche la configurazione di ogni azione (ad esempio, `send_email` richiede `type` e `template_id`, `wait` richiede `seconds`).

[Metti in pausa l’automazione](/it/docs/api-reference/automations/pause/) prima di cambiare il grafo di un’automazione attiva, poi [avviala](/it/docs/api-reference/automations/start/) di nuovo perché i nuovi trigger abbiano effetto.

`POST /automations/{id}`

## Parametri di percorso

- `id` (string, obbligatorio): L’ID dell’automazione (`aut_…`).

## Parametri del corpo

- `name` (string): Il nome, fino a 191 caratteri.

- `description` (string): La descrizione.

- `settings` (object): Sostituisce tutte le impostazioni: `on_step_failure`, `allow_reentry`, `max_concurrent_runs`, `cooldown_seconds`. Vedi [Impostazioni](/it/docs/api-reference/automations/create/#settings).

- `steps` (object[]): L’elenco completo dei passaggi. Obbligatorio quando invii `connections`. Vedi [Passaggi](/it/docs/api-reference/automations/create/#steps).

- `connections` (object[]): L’elenco completo dei collegamenti. Obbligatorio quando invii `steps`. Vedi [Collegamenti](/it/docs/api-reference/automations/create/#connections).

## Restituisce

Restituisce l’automazione aggiornata in `data`, con `message` e `notify`. Se la convalida non riesce restituisce `400` con `errors` organizzato per percorso del campo, e `404` se l’automazione non esiste.

**Richiesta** `POST /automations/{id}`

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Welcome series (v2)",
    "settings": { "allow_reentry": false, "on_step_failure": "skip" }
  }'
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.EMAILIT_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    name: 'Welcome series (v2)',
    settings: { allow_reentry: false, on_step_failure: 'skip' },
  }),
});
const { data: automation } = await res.json();
```

**Python**

```python
import os, requests

r = requests.post(
    "https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    json={
        "name": "Welcome series (v2)",
        "settings": {"allow_reentry": False, "on_step_failure": "skip"},
    },
)
automation = r.json()["data"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->post('automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'json' => [
        'name' => 'Welcome series (v2)',
        'settings' => ['allow_reentry' => false, 'on_step_failure' => 'skip'],
    ],
]);
$automation = json_decode($response->getBody(), true)['data'];
```

**200**

```json
{
  "data": {
    "id": "aut_3xqC9YD79FZZA36uTekWTBO1ghe",
    "context": "contact",
    "name": "Welcome series (v2)",
    "description": "Welcome new subscribers, then nudge free users a day later.",
    "status": "paused",
    "settings": { "allow_reentry": false, "on_step_failure": "skip" },
    "last_triggered_at": "2026-10-03T14:12:40.551870+00:00",
    "published_at": "2026-10-01T10:00:02.204118+00:00",
    "created_at": "2026-10-01T09:41:05.318274+00:00",
    "updated_at": "2026-10-04T08:15:22.730115+00:00",
    "steps": [
      {
        "id": "aus_3ZqpuxjmL1szZ8og6uGL1mT6QEJ",
        "key": "joined",
        "type": "trigger",
        "trigger": "contact.added_to_audience",
        "action": null,
        "config": { "audience_id": "aud_3Cz7WJ9GpvD7P0PQez50xOmkZSV" }
      },
      {
        "id": "aus_3V5TZIXXak1SSmGcOmzPOeFaguQ",
        "key": "welcome_email",
        "type": "action",
        "trigger": null,
        "action": "send_email",
        "config": { "type": "template", "template_id": "welcome", "from": "Acme <hello@acme.com>" }
      }
    ],
    "connections": [
      { "from": "joined", "to": "welcome_email", "branch": "default" }
    ]
  },
  "message": "Automation was successfully updated.",
  "notify": true
}
```

**400**

```json
{
  "message": "Validation failed.",
  "errors": {
    "steps.2.config.seconds": ["Wait seconds cannot exceed 2592000 (30 days)."],
    "steps.1.config.template_id": ["Template ID is required when type is \"template\"."]
  }
}
```

**404**

```json
{
  "message": "Automation not found."
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/automations/update/

## Elenca le automazioni — GET /automations

> Elenca le automazioni di un workspace con la paginazione page e per_page, filtrate per contesto, stato o nome.

# Elenca le automazioni

Restituisce le automazioni del workspace, a partire dalla più recente, senza i loro passaggi e collegamenti. Richiede una chiave API con il permesso `full`. Le automazioni eliminate non vengono elencate.

`GET /automations`

## Parametri di query

- `page` (integer): Numero di pagina, a partire da 1.

- `per_page` (integer): Automazioni per pagina, da 1 a 100.

- `filter[context]` (string): Solo le automazioni con questo contesto: `contact`, `email` o `event`.

- `filter[status]` (string): Solo le automazioni con questo stato: `draft`, `running`, `paused`, `stopped` o `archived`.

- `filter[name]` (string): Corrispondenza su una parte del nome, senza distinzione tra maiuscole e minuscole.

- `sort` (string): Campo di ordinamento: `name`, `created_at`, `updated_at` o `last_triggered_at`.

- `order` (string): Direzione dell’ordinamento: `asc` o `desc`.

Puoi usare anche i filtri generici `key.condition=value` su `name`, `status`, `context` e `created_at`, con `match`. Vedi [Filtri e ordinamento](/it/docs/api-reference/filtering/).

## Restituisce

- `data` (object[]): Le automazioni di questa pagina: `id`, `context`, `name`, `description`, `status`, `settings`, `last_triggered_at`, `published_at`, `created_at`, `updated_at`. In questo elenco `settings` è sempre un oggetto vuoto; per leggerlo, [recupera l’automazione](/it/docs/api-reference/automations/get/).

- `total_records` (integer): Numero di automazioni corrispondenti.

- `per_page` (integer): Dimensione di pagina usata.

- `current_page` (integer): Il numero di questa pagina.

- `total_pages` (integer): Numero di pagine.

**Richiesta** `GET /automations`

**cURL**

```bash
curl -G https://api.emailit.com/v2/automations \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  --data-urlencode "filter[status]=running" \
  -d sort=last_triggered_at \
  -d per_page=50
```

**Node.js**

```javascript
const params = new URLSearchParams({ 'filter[status]': 'running', sort: 'last_triggered_at', per_page: '50' });
const res = await fetch(`https://api.emailit.com/v2/automations?${params}`, {
  headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` },
});
const { data, total_pages } = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.emailit.com/v2/automations",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    params={"filter[status]": "running", "sort": "last_triggered_at", "per_page": 50},
)
automations = r.json()["data"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->get('automations', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'query' => ['filter[status]' => 'running', 'sort' => 'last_triggered_at', 'per_page' => 50],
]);
$automations = json_decode($response->getBody(), true)['data'];
```

**200**

```json
{
  "data": [
    {
      "id": "aut_3xqC9YD79FZZA36uTekWTBO1ghe",
      "context": "contact",
      "name": "Welcome series",
      "description": "Welcome new subscribers, then nudge free users a day later.",
      "status": "running",
      "settings": {},
      "last_triggered_at": "2026-10-03T14:12:40.551870+00:00",
      "published_at": "2026-10-01T10:00:02.204118+00:00",
      "created_at": "2026-10-01T09:41:05.318274+00:00",
      "updated_at": "2026-10-03T14:12:40.551870+00:00"
    }
  ],
  "total_records": 1,
  "per_page": 50,
  "current_page": 1,
  "total_pages": 1
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/automations/list/

## Elimina un’automazione — DELETE /automations/{id}

> Elimina un’automazione perché smetta di reagire ai trigger. Se vuoi annullare anche le esecuzioni in corso, prima interrompila.

# Elimina un’automazione

Elimina un’automazione. L’automazione scompare dagli elenchi e smette di reagire ai trigger. Richiede una chiave API con il permesso `full`.

Le esecuzioni già in corso non vengono annullate. Per annullarle, [interrompi l’automazione](/it/docs/api-reference/automations/stop/) prima di eliminarla.

`DELETE /automations/{id}`

## Parametri di percorso

- `id` (string, obbligatorio): L’ID dell’automazione (`aut_…`).

## Restituisce

Restituisce un `message` che conferma l’eliminazione. Restituisce `404` se l’automazione non esiste o è già stata eliminata.

**Richiesta** `DELETE /automations/{id}`

**cURL**

```bash
curl -X DELETE https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe', {
  method: 'DELETE',
  headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` },
});
const result = await res.json();
```

**Python**

```python
import os, requests

r = requests.delete(
    "https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
)
result = r.json()
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->delete('automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
]);
$result = json_decode($response->getBody(), true);
```

**200**

```json
{
  "message": "Automation was deleted successfully.",
  "notify": true
}
```

**404**

```json
{
  "message": "Automation not found."
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/automations/delete/

## Avvia un’automazione — POST /automations/{id}/start

> Imposta un’automazione su running perché i suoi trigger avviino nuove esecuzioni. Funziona con le automazioni in bozza, in pausa e interrotte.

# Avvia un’automazione

Imposta lo stato dell’automazione su `running`. Da quel momento i trigger corrispondenti avviano esecuzioni; gli eventi avvenuti prima dell’avvio no. Richiede una chiave API con il permesso `full`.

Puoi avviare un’automazione `draft`, `paused` o `stopped`. Il primo avvio imposta `published_at`.

L’avvio non convalida di nuovo il grafo. Se hai creato l’automazione con [Crea un’automazione](/it/docs/api-reference/automations/create/), che controlla solo la struttura, assicurati che la configurazione di ogni azione sia completa, oppure invia una volta il grafo tramite [Aggiorna un’automazione](/it/docs/api-reference/automations/update/), che lo convalida per intero. Un passaggio con una configurazione incompleta non riesce quando un’esecuzione lo raggiunge.

`POST /automations/{id}/start`

## Parametri di percorso

- `id` (string, obbligatorio): L’ID dell’automazione (`aut_…`).

## Restituisce

Restituisce l’automazione in `data` con `status` impostato su `running`. Restituisce `404` se l’automazione non esiste.

**Richiesta** `POST /automations/{id}/start`

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/start \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/start', {
  method: 'POST',
  headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` },
});
const { data: automation } = await res.json();
```

**Python**

```python
import os, requests

r = requests.post(
    "https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/start",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
)
automation = r.json()["data"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->post('automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/start', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
]);
$automation = json_decode($response->getBody(), true)['data'];
```

**200**

```json
{
  "data": {
    "id": "aut_3xqC9YD79FZZA36uTekWTBO1ghe",
    "context": "contact",
    "name": "Welcome series",
    "description": "Welcome new subscribers, then nudge free users a day later.",
    "status": "running",
    "settings": { "allow_reentry": false },
    "last_triggered_at": null,
    "published_at": "2026-10-01T10:00:02.204118+00:00",
    "created_at": "2026-10-01T09:41:05.318274+00:00",
    "updated_at": "2026-10-01T10:00:02.204118+00:00",
    "steps": [
      {
        "id": "aus_3ZqpuxjmL1szZ8og6uGL1mT6QEJ",
        "key": "joined",
        "type": "trigger",
        "trigger": "contact.added_to_audience",
        "action": null,
        "config": { "audience_id": "aud_3Cz7WJ9GpvD7P0PQez50xOmkZSV" }
      },
      {
        "id": "aus_3V5TZIXXak1SSmGcOmzPOeFaguQ",
        "key": "welcome_email",
        "type": "action",
        "trigger": null,
        "action": "send_email",
        "config": { "type": "template", "template_id": "welcome", "from": "Acme <hello@acme.com>" }
      }
    ],
    "connections": [
      { "from": "joined", "to": "welcome_email", "branch": "default" }
    ]
  },
  "message": "Automation was successfully started.",
  "notify": true
}
```

**404**

```json
{
  "message": "Automation not found."
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/automations/start/

## Metti in pausa un’automazione — POST /automations/{id}/pause

> Metti in pausa un’automazione perché i suoi trigger smettano di avviare nuove esecuzioni, mentre quelle già in corso proseguono fino alla fine.

# Metti in pausa un’automazione

Imposta lo stato dell’automazione su `paused`. I suoi trigger smettono di avviare nuove esecuzioni, ma le esecuzioni già in corso proseguono, comprese quelle in attesa su un passaggio `wait`. Richiede una chiave API con il permesso `full`.

Per annullare anche le esecuzioni in corso, [interrompi l’automazione](/it/docs/api-reference/automations/stop/) invece di metterla in pausa. Per far scattare di nuovo i trigger, [avviala](/it/docs/api-reference/automations/start/) un’altra volta.

`POST /automations/{id}/pause`

## Parametri di percorso

- `id` (string, obbligatorio): L’ID dell’automazione (`aut_…`).

## Restituisce

Restituisce l’automazione in `data` con `status` impostato su `paused`. Restituisce `404` se l’automazione non esiste.

**Richiesta** `POST /automations/{id}/pause`

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/pause \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/pause', {
  method: 'POST',
  headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` },
});
const { data: automation } = await res.json();
```

**Python**

```python
import os, requests

r = requests.post(
    "https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/pause",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
)
automation = r.json()["data"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->post('automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/pause', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
]);
$automation = json_decode($response->getBody(), true)['data'];
```

**200**

```json
{
  "data": {
    "id": "aut_3xqC9YD79FZZA36uTekWTBO1ghe",
    "context": "contact",
    "name": "Welcome series",
    "description": "Welcome new subscribers, then nudge free users a day later.",
    "status": "paused",
    "settings": { "allow_reentry": false },
    "last_triggered_at": "2026-10-03T14:12:40.551870+00:00",
    "published_at": "2026-10-01T10:00:02.204118+00:00",
    "created_at": "2026-10-01T09:41:05.318274+00:00",
    "updated_at": "2026-10-04T08:10:51.004732+00:00",
    "steps": [
      {
        "id": "aus_3ZqpuxjmL1szZ8og6uGL1mT6QEJ",
        "key": "joined",
        "type": "trigger",
        "trigger": "contact.added_to_audience",
        "action": null,
        "config": { "audience_id": "aud_3Cz7WJ9GpvD7P0PQez50xOmkZSV" }
      },
      {
        "id": "aus_3V5TZIXXak1SSmGcOmzPOeFaguQ",
        "key": "welcome_email",
        "type": "action",
        "trigger": null,
        "action": "send_email",
        "config": { "type": "template", "template_id": "welcome", "from": "Acme <hello@acme.com>" }
      }
    ],
    "connections": [
      { "from": "joined", "to": "welcome_email", "branch": "default" }
    ]
  },
  "message": "Automation was successfully paused.",
  "notify": true
}
```

**404**

```json
{
  "message": "Automation not found."
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/automations/pause/

## Interrompi un’automazione — POST /automations/{id}/stop

> Interrompi un’automazione e annulla tutte le sue esecuzioni in corso. Disponibile solo tramite l’API, non nel pannello.

# Interrompi un’automazione

Imposta lo stato dell’automazione su `stopped` e annulla ogni esecuzione ancora `running`; queste esecuzioni passano allo stato `canceled` e i passaggi rimanenti non vengono eseguiti. Richiede una chiave API con il permesso `full`.

L’interruzione è disponibile solo tramite l’API. Per lasciare proseguire le esecuzioni in corso, [metti in pausa l’automazione](/it/docs/api-reference/automations/pause/) invece di interromperla. Puoi [avviare](/it/docs/api-reference/automations/start/) di nuovo un’automazione interrotta; le nuove esecuzioni ripartono da zero.

`POST /automations/{id}/stop`

## Parametri di percorso

- `id` (string, obbligatorio): L’ID dell’automazione (`aut_…`).

## Restituisce

Restituisce l’automazione in `data` con `status` impostato su `stopped`. Restituisce `404` se l’automazione non esiste.

**Richiesta** `POST /automations/{id}/stop`

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/stop \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/stop', {
  method: 'POST',
  headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` },
});
const { data: automation } = await res.json();
```

**Python**

```python
import os, requests

r = requests.post(
    "https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/stop",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
)
automation = r.json()["data"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->post('automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/stop', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
]);
$automation = json_decode($response->getBody(), true)['data'];
```

**200**

```json
{
  "data": {
    "id": "aut_3xqC9YD79FZZA36uTekWTBO1ghe",
    "context": "contact",
    "name": "Welcome series",
    "description": "Welcome new subscribers, then nudge free users a day later.",
    "status": "stopped",
    "settings": { "allow_reentry": false },
    "last_triggered_at": "2026-10-03T14:12:40.551870+00:00",
    "published_at": "2026-10-01T10:00:02.204118+00:00",
    "created_at": "2026-10-01T09:41:05.318274+00:00",
    "updated_at": "2026-10-05T16:45:09.882301+00:00",
    "steps": [
      {
        "id": "aus_3ZqpuxjmL1szZ8og6uGL1mT6QEJ",
        "key": "joined",
        "type": "trigger",
        "trigger": "contact.added_to_audience",
        "action": null,
        "config": { "audience_id": "aud_3Cz7WJ9GpvD7P0PQez50xOmkZSV" }
      },
      {
        "id": "aus_3V5TZIXXak1SSmGcOmzPOeFaguQ",
        "key": "welcome_email",
        "type": "action",
        "trigger": null,
        "action": "send_email",
        "config": { "type": "template", "template_id": "welcome", "from": "Acme <hello@acme.com>" }
      }
    ],
    "connections": [
      { "from": "joined", "to": "welcome_email", "branch": "default" }
    ]
  },
  "message": "Automation was successfully stopped.",
  "notify": true
}
```

**404**

```json
{
  "message": "Automation not found."
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/automations/stop/

## Avvia un’esecuzione — POST /automations/{id}/trigger

> Fai scattare il trigger system.manual di un’automazione attiva con un payload tuo, per avviare un’esecuzione dal tuo codice.

# Avvia un’esecuzione

Fa scattare il trigger `system.manual` con un payload a tua scelta. L’automazione deve essere `running` e avere un passaggio trigger `system.manual`; altrimenti non parte nessuna esecuzione. Richiede una chiave API con il permesso `full`. I trigger manuali sono disponibili solo tramite l’API.

L’esecuzione parte in modo asincrono e costa 3 crediti come qualsiasi altra esecuzione. La trovi con [Elenca le esecuzioni](/it/docs/api-reference/automations/runs/).

> **Scattano tutti i trigger manuali del workspace:** Per ora Emailit consegna il trigger manuale a ogni automazione attiva del workspace che ha un passaggio trigger `system.manual`, non solo a quella indicata nel percorso. Per limitare un’automazione alle chiamate che la riguardano, aggiungi un filtro al suo passaggio trigger: `{ "match": "all", "rules": [{ "field": "automation_id", "operator": "equals", "value": "aut_…" }] }`.

`POST /automations/{id}/trigger`

## Parametri di percorso

- `id` (string, obbligatorio): L’ID dell’automazione (`aut_…`).

## Parametri del corpo

- `payload` (object): I dati per l’esecuzione. Emailit aggiunge `automation_id` e salva il risultato come `payload` dell’esecuzione. I passaggi possono leggerlo con segnaposto come `{{payload.order_id}}` e con condizioni come `payload.plan`. Di cosa tratta l’esecuzione dipende dal contesto dell’automazione: - `contact`: passa `contact_id` (`con_…`). Le azioni sui contatti e `send_email` usano quel contatto. - `email`: passa `email_id` (`em_…`). Le azioni sulle email usano quell’email. - `event`: dati qualsiasi. Imposta `to` o `email` nella configurazione delle azioni, ad esempio `"to": "{{payload.customer_email}}"`.

## Restituisce

Restituisce `200` con un `message` quando il trigger è stato messo in coda. Restituisce `422` se l’automazione non è `running` e `404` se non esiste.

**Richiesta** `POST /automations/{id}/trigger`

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/trigger \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "payload": {
      "contact_id": "con_3munwNLaXKUARc6ff9wPtxKVq4A",
      "plan": "pro",
      "order_id": "ord_1042"
    }
  }'
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/trigger', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.EMAILIT_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    payload: { contact_id: 'con_3munwNLaXKUARc6ff9wPtxKVq4A', plan: 'pro', order_id: 'ord_1042' },
  }),
});
const result = await res.json();
```

**Python**

```python
import os, requests

r = requests.post(
    "https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/trigger",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    json={"payload": {"contact_id": "con_3munwNLaXKUARc6ff9wPtxKVq4A", "plan": "pro", "order_id": "ord_1042"}},
)
result = r.json()
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->post('automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/trigger', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'json' => [
        'payload' => ['contact_id' => 'con_3munwNLaXKUARc6ff9wPtxKVq4A', 'plan' => 'pro', 'order_id' => 'ord_1042'],
    ],
]);
$result = json_decode($response->getBody(), true);
```

**200**

```json
{
  "message": "Automation trigger dispatched."
}
```

**422**

```json
{
  "message": "Automation must be running to trigger."
}
```

**404**

```json
{
  "message": "Automation not found."
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/automations/trigger/

## Elenca le esecuzioni — GET /automations/{id}/runs

> Elenca le esecuzioni di un’automazione, a partire dalla più recente, con l’evento che le ha avviate, il payload, lo stato e i tempi di ciascuna.

# Elenca le esecuzioni

Restituisce le esecuzioni di un’automazione, a partire dalla più recente. Ogni esecuzione è un percorso attraverso il grafo, avviato da un trigger. Richiede una chiave API con il permesso `full`.

`GET /automations/{id}/runs`

## Parametri di percorso

- `id` (string, obbligatorio): L’ID dell’automazione (`aut_…`).

## Parametri di query

- `page` (integer): Numero di pagina, a partire da 1.

- `per_page` (integer): Esecuzioni per pagina, da 1 a 100.

- `filter[status]` (string): Solo le esecuzioni con questo stato: `running`, `completed`, `failed` o `canceled`.

Puoi anche filtrare con `key.condition=value` su `status`, `event` e `created_at` (ad esempio `created_at.after=2026-10-01`) e ordinare con `order` e `direction` sulle stesse chiavi. Vedi [Filtri e ordinamento](/it/docs/api-reference/filtering/).

## Restituisce

- `data` (object[]): Le esecuzioni di questa pagina. Vedi i campi qui sotto.

- `total_records, per_page, current_page, total_pages` (integer): I dettagli della paginazione.

Ogni esecuzione ha:

- `id` (string): L’ID dell’esecuzione, con prefisso `aur_`.

- `automation_id` (string): L’automazione (`aut_…`).

- `contact_id` (string | null): Il contatto dell’esecuzione (`con_…`) nel contesto `contact`.

- `email_id` (string | null): L’email dell’esecuzione (`em_…`) nel contesto `email`.

- `event_id` (string | null): L’ID dell’evento di origine, quando il payload del trigger ne ha uno.

- `event` (string): Il trigger che ha avviato l’esecuzione, ad esempio `contact.added_to_audience` o `system.manual`.

- `payload` (object): In questo elenco è sempre un oggetto vuoto. Per leggere il payload del trigger, [recupera l’esecuzione](/it/docs/api-reference/automations/run/).

- `meta` (object): In questo elenco è sempre un oggetto vuoto. Per leggere i metadati, come `failure_reason`, recupera l’esecuzione.

- `status` (string): `running`, `completed`, `failed` o `canceled` (l’automazione è stata interrotta).

- `started_at, completed_at, created_at, updated_at` (string | null): Timestamp in UTC.

**Richiesta** `GET /automations/{id}/runs`

**cURL**

```bash
curl -G https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/runs \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  --data-urlencode "filter[status]=failed"
```

**Node.js**

```javascript
const params = new URLSearchParams({ 'filter[status]': 'failed' });
const res = await fetch(
  `https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/runs?${params}`,
  { headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` } },
);
const { data: runs } = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/runs",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    params={"filter[status]": "failed"},
)
runs = r.json()["data"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->get('automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/runs', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'query' => ['filter[status]' => 'failed'],
]);
$runs = json_decode($response->getBody(), true)['data'];
```

**200**

```json
{
  "data": [
    {
      "id": "aur_3q6GdFk2eRSG093grI0v9e6REu8",
      "automation_id": "aut_3xqC9YD79FZZA36uTekWTBO1ghe",
      "contact_id": "con_3munwNLaXKUARc6ff9wPtxKVq4A",
      "email_id": null,
      "event_id": null,
      "event": "contact.added_to_audience",
      "payload": {},
      "meta": {},
      "status": "failed",
      "started_at": "2026-10-03T14:12:40.551870+00:00",
      "completed_at": "2026-10-03T14:12:41.093355+00:00",
      "created_at": "2026-10-03T14:12:40.551870+00:00",
      "updated_at": "2026-10-03T14:12:41.093355+00:00"
    }
  ],
  "total_records": 1,
  "per_page": 25,
  "current_page": 1,
  "total_pages": 1
}
```

**404**

```json
{
  "message": "Automation not found."
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/automations/runs/

## Recupera un’esecuzione — GET /automations/{id}/runs/{run_id}

> Recupera un’esecuzione di un’automazione con il payload del trigger, i metadati e lo stato e il risultato di ogni passaggio eseguito.

# Recupera un’esecuzione

Recupera un’esecuzione di un’automazione, compresi i passaggi che ha eseguito. Richiede una chiave API con il permesso `full`.

`GET /automations/{id}/runs/{run_id}`

## Parametri di percorso

- `id` (string, obbligatorio): L’ID dell’automazione (`aut_…`).

- `run_id` (string, obbligatorio): L’ID dell’esecuzione (`aur_…`).

## Restituisce

Restituisce l’esecuzione in `data` con i campi descritti in [Elenca le esecuzioni](/it/docs/api-reference/automations/runs/), più `payload` e `meta` completi e un array `run_steps`.

- `payload` (object | null): Il payload del trigger: i dati dell’evento (`{ "object": { … } }`) o il payload che hai passato ad [Avvia un’esecuzione](/it/docs/api-reference/automations/trigger/), con l’aggiunta di `automation_id`.

- `meta` (object | null): `source_event_id` collega l’esecuzione all’evento che l’ha avviata. Le esecuzioni non riuscite possono avere `failure_reason`: `insufficient_credits` (non è stato possibile addebitare i 3 crediti dell’esecuzione) o `run_timeout` (l’esecuzione era ancora `running` dopo 72 ore senza alcun passaggio in attesa).

- `run_steps` (object[]): Una voce per ogni passaggio raggiunto dall’esecuzione: - `step_id`: l’ID del passaggio (`aus_…`). Confrontalo con `steps[].id` di [Recupera un’automazione](/it/docs/api-reference/automations/get/). - `status`: `running`, `waiting` (un passaggio `wait` non ancora trascorso), `completed` o `failed`. - `data`: il risultato del passaggio. Ad esempio `send_email` restituisce `{ "result": "email_queued", "email_oid": "em_…", "to": "…" }`, `condition` restituisce `{ "result": true, "branch": "yes" }` e i passaggi non riusciti restituiscono `{ "error": "…" }`. - `started_at`, `completed_at`, `created_at`.

Restituisce `404` se l’automazione o l’esecuzione non esiste.

**Richiesta** `GET /automations/{id}/runs/{run_id}`

**cURL**

```bash
curl https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/runs/aur_3q6GdFk2eRSG093grI0v9e6REu8 \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**Node.js**

```javascript
const res = await fetch(
  'https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/runs/aur_3q6GdFk2eRSG093grI0v9e6REu8',
  { headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` } },
);
const { data: run } = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/runs/aur_3q6GdFk2eRSG093grI0v9e6REu8",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
)
run = r.json()["data"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->get('automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/runs/aur_3q6GdFk2eRSG093grI0v9e6REu8', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
]);
$run = json_decode($response->getBody(), true)['data'];
```

**200**

```json
{
  "data": {
    "id": "aur_3q6GdFk2eRSG093grI0v9e6REu8",
    "automation_id": "aut_3xqC9YD79FZZA36uTekWTBO1ghe",
    "contact_id": "con_3munwNLaXKUARc6ff9wPtxKVq4A",
    "email_id": null,
    "event_id": null,
    "event": "contact.added_to_audience",
    "payload": {
      "object": {
        "id": "sub_3Fh2pQx9LmZr4Wt7Nc0bVd8KsYe",
        "object": "subscriber",
        "subscribed": true,
        "audience": { "id": "aud_3Cz7WJ9GpvD7P0PQez50xOmkZSV", "name": "Newsletter" },
        "contact": { "id": "con_3munwNLaXKUARc6ff9wPtxKVq4A", "email": "ada@example.com" }
      }
    },
    "meta": { "source_event_id": "evt_3Kd8sWq1NzXc5Vb7Mt2LpRy0HgA" },
    "status": "running",
    "started_at": "2026-10-03T14:12:40.551870+00:00",
    "completed_at": null,
    "created_at": "2026-10-03T14:12:40.551870+00:00",
    "updated_at": "2026-10-03T14:12:40.551870+00:00",
    "run_steps": [
      {
        "step_id": "aus_3V5TZIXXak1SSmGcOmzPOeFaguQ",
        "status": "completed",
        "data": {
          "result": "email_queued",
          "outcome": "accepted",
          "email_oid": "em_3Cp8cMgPskzB8tIlgUyNJkpDp9O",
          "to": "ada@example.com"
        },
        "started_at": "2026-10-03T14:12:40.702113+00:00",
        "completed_at": "2026-10-03T14:12:40.918540+00:00",
        "created_at": "2026-10-03T14:12:40.702113+00:00"
      },
      {
        "step_id": "aus_3vM0ORwEXCQcyS7rylfQBQEXjVk",
        "status": "waiting",
        "data": { "status": "waiting", "delayMs": 86400000, "seconds": 86400 },
        "started_at": "2026-10-03T14:12:41.004221+00:00",
        "completed_at": null,
        "created_at": "2026-10-03T14:12:41.004221+00:00"
      }
    ]
  }
}
```

**404**

```json
{
  "message": "Run not found."
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/automations/run/

## Recupera le statistiche — GET /automations/{id}/stats

> Ottieni i conteggi per passaggio di un’automazione: quante esecuzioni hanno raggiunto ogni passaggio, gli stati dei passaggi, gli esiti e un funnel delle email.

# Recupera le statistiche

Restituisce i conteggi di ogni passaggio di un’automazione, indicizzati per chiave del passaggio. Richiede una chiave API con il permesso `full`.

`GET /automations/{id}/stats`

## Parametri di percorso

- `id` (string, obbligatorio): L’ID dell’automazione (`aut_…`).

## Parametri di query

- `since` (string): Conta solo le esecuzioni dei passaggi create in questo momento o dopo. Data e ora RFC 3339, ad esempio `2026-10-01T00:00:00Z`.

- `until` (string): Conta solo le esecuzioni dei passaggi create in questo momento o prima. Data e ora RFC 3339.

- `run_ids[]` (string): Conta solo queste esecuzioni (`aur_…`). Ripeti il parametro per indicare più esecuzioni.

## Restituisce

Restituisce `data`, un oggetto con una voce per ogni chiave di passaggio. I passaggi che nessuna esecuzione ha raggiunto hanno `total` pari a `0`.

- `total` (integer): Quante volte le esecuzioni hanno raggiunto il passaggio.

- `by_status` (object): Conteggi per stato del passaggio: `running`, `waiting`, `completed`, `failed`.

- `by_outcome` (object): Conteggi per esito. `send_email` e `forward_email`: `accepted`, poi lo stato più recente dell’email (`delivered`, `loaded`, `clicked`, `bounced`, `failed`, `complained`, `unsubscribed`, `canceled`). `condition`: `matched`, `not_matched`. `experiment`: la chiave della variante scelta. `call_webhook`: `2xx`, `4xx`, `5xx`, `timeout`, `network_error`. Passaggi non riusciti: `error`.

- `funnel` (object): Solo per i passaggi `send_email`. Conteggi cumulativi: `accepted` include ogni email che è andata oltre, `delivered` include le email caricate e cliccate, e `loaded` include quelle cliccate. `bounced`, `failed`, `complained` e `unsubscribed` sono conteggi semplici.

**Richiesta** `GET /automations/{id}/stats`

**cURL**

```bash
curl -G https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/stats \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -d since=2026-10-01T00:00:00Z
```

**Node.js**

```javascript
const params = new URLSearchParams({ since: '2026-10-01T00:00:00Z' });
const res = await fetch(
  `https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/stats?${params}`,
  { headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` } },
);
const { data: stats } = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/stats",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    params={"since": "2026-10-01T00:00:00Z"},
)
stats = r.json()["data"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->get('automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/stats', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'query' => ['since' => '2026-10-01T00:00:00Z'],
]);
$stats = json_decode($response->getBody(), true)['data'];
```

**200**

```json
{
  "data": {
    "joined": { "total": 0, "by_status": {}, "by_outcome": {} },
    "welcome_email": {
      "total": 412,
      "by_status": { "completed": 409, "failed": 3 },
      "by_outcome": { "delivered": 251, "loaded": 98, "clicked": 41, "bounced": 19, "error": 3 },
      "funnel": {
        "accepted": 390,
        "delivered": 390,
        "loaded": 139,
        "clicked": 41,
        "bounced": 19,
        "failed": 0,
        "complained": 0,
        "unsubscribed": 0
      }
    },
    "wait_1_day": {
      "total": 409,
      "by_status": { "completed": 352, "waiting": 57 },
      "by_outcome": {}
    },
    "is_free_user": {
      "total": 352,
      "by_status": { "completed": 352 },
      "by_outcome": { "matched": 270, "not_matched": 82 }
    },
    "upgrade_tips": {
      "total": 270,
      "by_status": { "completed": 270 },
      "by_outcome": { "accepted": 12, "delivered": 180, "loaded": 61, "clicked": 17 },
      "funnel": {
        "accepted": 270,
        "delivered": 258,
        "loaded": 78,
        "clicked": 17,
        "bounced": 0,
        "failed": 0,
        "complained": 0,
        "unsubscribed": 0
      }
    },
    "done": {
      "total": 82,
      "by_status": { "completed": 82 },
      "by_outcome": {}
    }
  }
}
```

**404**

```json
{
  "message": "Automation not found."
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/automations/stats/

## Recupera le statistiche dei passaggi — GET /automations/{id}/steps/{step_key}/stats

> Ottieni i conteggi di un singolo passaggio di un’automazione tramite la sua chiave: esecuzioni, stati, esiti e il funnel delle email.

# Recupera le statistiche dei passaggi

Restituisce i conteggi di un passaggio di un’automazione. Richiede una chiave API con il permesso `full`. I campi sono gli stessi di [Recupera le statistiche](/it/docs/api-reference/automations/stats/).

`GET /automations/{id}/steps/{step_key}/stats`

## Parametri di percorso

- `id` (string, obbligatorio): L’ID dell’automazione (`aut_…`).

- `step_key` (string, obbligatorio): La `key` del passaggio, ad esempio `welcome_email`.

## Parametri di query

- `since` (string): Conta solo le esecuzioni dei passaggi create in questo momento o dopo. Data e ora RFC 3339.

- `until` (string): Conta solo le esecuzioni dei passaggi create in questo momento o prima. Data e ora RFC 3339.

## Restituisce

Restituisce `data` con `total`, `by_status`, `by_outcome` e, per i passaggi `send_email`, `funnel`. Restituisce `404` se l’automazione o la chiave del passaggio non esiste.

**Richiesta** `GET /automations/{id}/steps/{step_key}/stats`

**cURL**

```bash
curl https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/steps/welcome_email/stats \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**Node.js**

```javascript
const res = await fetch(
  'https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/steps/welcome_email/stats',
  { headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` } },
);
const { data: stats } = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.emailit.com/v2/automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/steps/welcome_email/stats",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
)
stats = r.json()["data"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->get('automations/aut_3xqC9YD79FZZA36uTekWTBO1ghe/steps/welcome_email/stats', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
]);
$stats = json_decode($response->getBody(), true)['data'];
```

**200**

```json
{
  "data": {
    "total": 412,
    "by_status": { "completed": 409, "failed": 3 },
    "by_outcome": { "delivered": 251, "loaded": 98, "clicked": 41, "bounced": 19, "error": 3 },
    "funnel": {
      "accepted": 390,
      "delivered": 390,
      "loaded": 139,
      "clicked": 41,
      "bounced": 19,
      "failed": 0,
      "complained": 0,
      "unsubscribed": 0
    }
  }
}
```

**404**

```json
{
  "message": "Step not found."
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/automations/step-stats/