# Campagne API

> Crea campagne, scegli le liste e inviale o programmale.

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

## Crea una campagna — POST /campaigns

> Crea una campagna email in bozza con mittente, oggetto e corpo HTML o di testo, pronta per scegliere le liste e inviarla.

# Crea una campagna

Crea una campagna nello stato `draft`. Richiede una chiave API con il permesso `full`. Genera un evento `campaign.created`.

Una nuova campagna non ha destinatari. Scegli le sue liste con [Aggiorna una campagna](/it/docs/api-reference/campaigns/update/), poi [inviala o programmala](/it/docs/api-reference/campaigns/send/). I crediti vengono addebitati quando la campagna viene inviata: 2 crediti per email.

`POST /campaigns`

## Parametri del corpo

- `name` (string, obbligatorio): Nome interno della campagna. I destinatari non lo vedono. Gli altri endpoint delle campagne accettano il nome al posto dell’ID, quindi se li usi in questo modo mantieni i nomi univoci.

- `subject` (string): Riga dell’oggetto. Supporta [tag di unione](/it/docs/campaigns/merge-tags/) come `{{first_name}}`.

- `from_email` (string): Indirizzo del mittente. Deve appartenere a un dominio di invio verificato del workspace, ad esempio `news@acme.com`.

- `from_name` (string): Nome visualizzato del mittente, ad esempio `Acme`. Il messaggio viene inviato da `Acme <news@acme.com>`.

- `reply_to` (string): Indirizzo Reply-To. Quando la campagna viene inviata, il valore predefinito è `from_email`.

- `html` (string): Corpo HTML che Emailit invia. Supporta i tag di unione `{{first_name}}`, `{{last_name}}`, `{{email}}`, `{{unsubscribe_url}}` e `{{cf.<key>}}` per i campi personalizzati. Imposta il corpo quando crei la campagna.

- `text` (string): Corpo in testo semplice. Supporta gli stessi tag di unione di `html`.

- `preview_text` (string): Testo di anteprima salvato con la campagna. Emailit non lo inserisce nel messaggio; se ti serve, aggiungi a `html` un preheader nascosto.

- `content` (string): Sorgente del corpo nell’editor (ad esempio MJML), salvato così com’è. Emailit invia `html` e `text`, non `content`.

- `content_type` (string): Formato di `content`: `html`, `text` o `mjml`. Emailit non compila l’MJML; invia l’HTML compilato in `html`.

## Restituisce

Restituisce `201 Created` con l’oggetto campagna. `status` è `draft`. La risposta non riporta `html`, `text` né `content`.

Restituisce `400` se manca `name` e `403` se la chiave API non ha il permesso `full`.

**Richiesta** `POST /campaigns`

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/campaigns \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "October newsletter",
    "subject": "October news for {{first_name}}",
    "from_email": "news@acme.com",
    "from_name": "Acme",
    "reply_to": "support@acme.com",
    "html": "<p>Hi {{first_name}},</p><p>Here is what changed this month.</p><p><a href=\"{{unsubscribe_url}}\">Unsubscribe</a></p>",
    "text": "Hi {{first_name}}, here is what changed this month. Unsubscribe: {{unsubscribe_url}}"
  }'
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/campaigns', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.EMAILIT_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    name: 'October newsletter',
    subject: 'October news for {{first_name}}',
    from_email: 'news@acme.com',
    from_name: 'Acme',
    reply_to: 'support@acme.com',
    html: '<p>Hi {{first_name}},</p><p>Here is what changed this month.</p><p><a href="{{unsubscribe_url}}">Unsubscribe</a></p>',
    text: 'Hi {{first_name}}, here is what changed this month. Unsubscribe: {{unsubscribe_url}}',
  }),
});
const campaign = await res.json();
```

**Python**

```python
import os, requests

r = requests.post(
    "https://api.emailit.com/v2/campaigns",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    json={
        "name": "October newsletter",
        "subject": "October news for {{first_name}}",
        "from_email": "news@acme.com",
        "from_name": "Acme",
        "reply_to": "support@acme.com",
        "html": '<p>Hi {{first_name}},</p><p>Here is what changed this month.</p><p><a href="{{unsubscribe_url}}">Unsubscribe</a></p>',
        "text": "Hi {{first_name}}, here is what changed this month. Unsubscribe: {{unsubscribe_url}}",
    },
)
campaign = r.json()
```

**PHP**

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

$response = $client->post('campaigns', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'json' => [
        'name' => 'October newsletter',
        'subject' => 'October news for {{first_name}}',
        'from_email' => 'news@acme.com',
        'from_name' => 'Acme',
        'reply_to' => 'support@acme.com',
        'html' => '<p>Hi {{first_name}},</p><p>Here is what changed this month.</p><p><a href="{{unsubscribe_url}}">Unsubscribe</a></p>',
        'text' => 'Hi {{first_name}}, here is what changed this month. Unsubscribe: {{unsubscribe_url}}',
    ],
]);
$campaign = json_decode($response->getBody(), true);
```

**201**

```json
{
  "object": "campaign",
  "id": "cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN",
  "name": "October newsletter",
  "status": "draft",
  "subject": "October news for {{first_name}}",
  "from_email": "news@acme.com",
  "from_name": "Acme",
  "reply_to": "support@acme.com",
  "preview_text": null,
  "content_type": "html",
  "created_at": "2026-10-01T09:30:12.482193Z",
  "updated_at": "2026-10-01T09:30:12.482193Z"
}
```

**400**

```json
{
  "error": "Bad Request"
}
```

**403**

```json
{
  "statusCode": 403,
  "error": "Forbidden",
  "message": "Permission denied: campaigns:create"
}
```

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

## Recupera una campagna — GET /campaigns/{id}

> Recupera una campagna tramite ID o nome, con lo stato, il mittente, la programmazione e le liste a cui è destinata.

# Recupera una campagna

Recupera una campagna tramite il suo ID o nome. Richiede una chiave API con il permesso `full`.

`GET /campaigns/{id}`

## Parametri di percorso

- `id` (string, obbligatorio): L’ID della campagna (`cmp_…`) o il nome della campagna. Codifica per l’URL i nomi che contengono spazi o caratteri speciali.

## Restituisce

Restituisce l’oggetto campagna.

- `object` (string): Sempre `campaign`.

- `id` (string): ID della campagna, con prefisso `cmp_`.

- `status` (string): `draft`, `scheduled`, `queued`, `sending`, `sent`, `canceled` o `archived`. `queued` indica che una campagna programmata ha raggiunto l’orario di invio ed è in attesa di un worker.

- `name` (string): Nome interno della campagna.

- `subject` (string): Riga dell’oggetto, con i tag di unione non elaborati.

- `from_email` (string): Indirizzo del mittente. `""` finché non viene impostato.

- `from_name` (string): Nome visualizzato del mittente. `""` finché non viene impostato.

- `reply_to` (string): Indirizzo Reply-To. `""` significa che le risposte vanno a `from_email`.

- `preview_text` (string | null): Testo di anteprima salvato con la campagna.

- `content_type` (string): Etichetta del formato della sorgente dell’editor: `html`, `text` o `mjml` per le campagne create tramite l’API.

- `scheduled_at` (string | null): Quando viene inviata una campagna programmata, in UTC.

- `sent_at` (string | null): Quando è iniziato l’invio.

- `recipients` (object[]): Le liste a cui è destinata la campagna. Ogni elemento ha `audience_id` (`aud_…`) ed `exclude` (`true` per una lista esclusa).

Il corpo (`html`, `text` e `content`) non è incluso nella risposta. Le statistiche di engagement sono disponibili nel pannello in **Email Marketing → Campaigns**.

Restituisce `404` se nessuna campagna del workspace corrisponde a `id`.

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

**cURL**

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

**Node.js**

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

**Python**

```python
import os, requests

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

**PHP**

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

$response = $client->get('campaigns/cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
]);
$campaign = json_decode($response->getBody(), true);
```

**200**

```json
{
  "object": "campaign",
  "id": "cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN",
  "name": "October newsletter",
  "status": "scheduled",
  "subject": "October news for {{first_name}}",
  "from_email": "news@acme.com",
  "from_name": "Acme",
  "reply_to": "support@acme.com",
  "preview_text": null,
  "content_type": "html",
  "sent_at": null,
  "scheduled_at": "2026-10-08 09:00:00+00",
  "created_at": "2026-10-01 09:30:12.482193+00",
  "updated_at": "2026-10-01 10:02:47.118204+00",
  "recipients": [
    { "audience_id": "aud_3Cz7WJ9GpvD7P0PQez50xOmkZSV", "exclude": false },
    { "audience_id": "aud_3hRmYTSQ4ca6y9tbPI0IQPjVTL9", "exclude": true }
  ]
}
```

**404**

```json
{
  "error": "Campaign not found"
}
```

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

## Aggiorna una campagna — POST /campaigns/{id}

> Modifica il nome, il mittente, l’oggetto o il testo di anteprima di una campagna e imposta le liste a cui inviarla o da escludere.

# Aggiorna una campagna

Aggiorna i campi che passi e lascia invariati gli altri. Usalo per scegliere le liste della campagna prima di inviarla. Richiede una chiave API con il permesso `full`. Genera un evento `campaign.updated`.

Una campagna programmata invia ciò che è salvato al momento dell’invio, quindi puoi modificarla anche dopo averla programmata.

`POST /campaigns/{id}`

## Parametri di percorso

- `id` (string, obbligatorio): L’ID della campagna (`cmp_…`) o il nome della campagna.

## Parametri del corpo

- `name` (string): Nome interno della campagna.

- `subject` (string): Riga dell’oggetto. Supporta i [tag di unione](/it/docs/campaigns/merge-tags/).

- `from_email` (string): Indirizzo del mittente su un dominio di invio verificato.

- `from_name` (string): Nome visualizzato del mittente.

- `reply_to` (string): Indirizzo Reply-To. Una stringa vuota significa che le risposte vanno a `from_email`.

- `preview_text` (string): Testo di anteprima salvato con la campagna.

- `content` (string): Sorgente del corpo nell’editor, salvato così com’è.

- `content_type` (string): Formato di `content`: `html`, `text` o `mjml`.

- `recipients` (object[]): Le liste a cui destinare la campagna. Sostituisce l’elenco attuale. Includi almeno una lista con `exclude` impostato su `false`. - `audience_id` (string, obbligatorio): l’ID di una lista (`aud_…`) di questo workspace. - `exclude` (boolean, predefinito `false`): `true` salva la lista come esclusione. Il pannello sottrae le liste escluse dalla stima dei destinatari, ma per ora l’invio vero e proprio non applica le esclusioni, quindi rimuovi quei contatti anche dalle liste incluse. Gli ID di lista duplicati vengono ignorati. Al momento dell’invio, Emailit invia un’email una sola volta a ogni contatto iscritto alle liste incluse, e salta i contatti disiscritti e gli indirizzi soppressi.

Il corpo HTML e di testo si imposta quando [crei la campagna](/it/docs/api-reference/campaigns/create/). I campi sconosciuti nel corpo della richiesta vengono ignorati.

## Restituisce

Restituisce l’oggetto campagna aggiornato, compreso `recipients`.

Restituisce `422` se `recipients` non ha nessuna lista inclusa o fa riferimento a una lista esterna al workspace, e `404` se la campagna non esiste.

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

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/campaigns/cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "subject": "Your October update, {{first_name}}",
    "recipients": [
      { "audience_id": "aud_3Cz7WJ9GpvD7P0PQez50xOmkZSV" },
      { "audience_id": "aud_3hRmYTSQ4ca6y9tbPI0IQPjVTL9", "exclude": true }
    ]
  }'
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/campaigns/cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.EMAILIT_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    subject: 'Your October update, {{first_name}}',
    recipients: [
      { audience_id: 'aud_3Cz7WJ9GpvD7P0PQez50xOmkZSV' },
      { audience_id: 'aud_3hRmYTSQ4ca6y9tbPI0IQPjVTL9', exclude: true },
    ],
  }),
});
const campaign = await res.json();
```

**Python**

```python
import os, requests

r = requests.post(
    "https://api.emailit.com/v2/campaigns/cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    json={
        "subject": "Your October update, {{first_name}}",
        "recipients": [
            {"audience_id": "aud_3Cz7WJ9GpvD7P0PQez50xOmkZSV"},
            {"audience_id": "aud_3hRmYTSQ4ca6y9tbPI0IQPjVTL9", "exclude": True},
        ],
    },
)
campaign = r.json()
```

**PHP**

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

$response = $client->post('campaigns/cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'json' => [
        'subject' => 'Your October update, {{first_name}}',
        'recipients' => [
            ['audience_id' => 'aud_3Cz7WJ9GpvD7P0PQez50xOmkZSV'],
            ['audience_id' => 'aud_3hRmYTSQ4ca6y9tbPI0IQPjVTL9', 'exclude' => true],
        ],
    ],
]);
$campaign = json_decode($response->getBody(), true);
```

**200**

```json
{
  "object": "campaign",
  "id": "cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN",
  "name": "October newsletter",
  "status": "draft",
  "subject": "Your October update, {{first_name}}",
  "from_email": "news@acme.com",
  "from_name": "Acme",
  "reply_to": "support@acme.com",
  "preview_text": null,
  "content_type": "html",
  "scheduled_at": null,
  "created_at": "2026-10-01 09:30:12.482193+00",
  "updated_at": "2026-10-01 10:02:47.118204+00",
  "recipients": [
    { "audience_id": "aud_3Cz7WJ9GpvD7P0PQez50xOmkZSV", "exclude": false },
    { "audience_id": "aud_3hRmYTSQ4ca6y9tbPI0IQPjVTL9", "exclude": true }
  ]
}
```

**422**

```json
{
  "message": "Validation failed.",
  "errors": {
    "recipients": ["One or more audiences are invalid."]
  }
}
```

**404**

```json
{
  "error": "Campaign not found"
}
```

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

## Elenca le campagne — GET /campaigns

> Elenca le campagne di un workspace, a partire dalla più recente, con paginazione per pagine, ricerca e filtri per stato, nome e date.

# Elenca le campagne

Restituisce le campagne del workspace, a partire dalla più recente. Richiede una chiave API con il permesso `full`.

`GET /campaigns`

## Parametri di query

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

- `limit` (integer): Campagne per pagina, da 1 a 100.

- `search` (string): Corrispondenza sul nome o sull’oggetto della campagna, senza distinzione tra maiuscole e minuscole.

- `status` (string): Filtro rapido per stato: `draft`, `scheduled`, `sending` (corrisponde anche a `queued`), `sent`, `canceled`, `archived` o `all`.

- `match`, `order`, `direction`: vedi [Filtri e ordinamento](https://emailit.com/it/docs/api-reference/filtering/).

### Chiavi di filtro

I filtri usano parametri di query nella forma `key.condition=value`, ad esempio `status.exact=sent` o `created_at.after=2026-09-01`. Per le condizioni disponibili per ogni tipo, vedi [Filtri e ordinamento](/it/docs/api-reference/filtering/).

| Chiave | Tipo | Note |
| --- | --- | --- |
| `name` | string | |
| `subject` | string | |
| `status` | enum | `draft`, `scheduled`, `queued`, `sending`, `sent`, `archived` |
| `created_at` | date | |
| `sent_at` | date | |

Chiavi di ordinamento per `order`: `name`, `subject`, `status`, `created_at`, `sent_at`.

## Restituisce

Restituisce una pagina di oggetti campagna senza `reply_to`, `preview_text`, `content_type` e `recipients`. Per quei campi usa [Recupera una campagna](/it/docs/api-reference/campaigns/get/).

- `data` (object[]): Le campagne di questa pagina.

- `total_records` (integer): Numero di campagne che corrispondono alla query.

- `next_page_url` (string | null): Percorso della pagina successiva, oppure `null` sull’ultima pagina. Contiene solo `page` e `limit`, quindi quando lo segui aggiungi di nuovo la ricerca e i filtri.

- `previous_page_url` (string | null): Percorso della pagina precedente, oppure `null` sulla prima pagina.

**Richiesta** `GET /campaigns`

**cURL**

```bash
curl -G https://api.emailit.com/v2/campaigns \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -d limit=20 \
  -d status=sent \
  -d order=sent_at \
  -d direction=desc
```

**Node.js**

```javascript
const params = new URLSearchParams({ limit: '20', status: 'sent', order: 'sent_at', direction: 'desc' });
const res = await fetch(`https://api.emailit.com/v2/campaigns?${params}`, {
  headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` },
});
const { data, total_records } = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.emailit.com/v2/campaigns",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    params={"limit": 20, "status": "sent", "order": "sent_at", "direction": "desc"},
)
campaigns = r.json()["data"]
```

**PHP**

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

$response = $client->get('campaigns', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'query' => ['limit' => 20, 'status' => 'sent', 'order' => 'sent_at', 'direction' => 'desc'],
]);
$campaigns = json_decode($response->getBody(), true)['data'];
```

**200**

```json
{
  "data": [
    {
      "object": "campaign",
      "id": "cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN",
      "name": "October newsletter",
      "status": "sent",
      "subject": "Your October update, {{first_name}}",
      "from_email": "news@acme.com",
      "from_name": "Acme",
      "sent_at": "2026-10-08 09:00:04+00",
      "scheduled_at": "2026-10-08 09:00:00+00",
      "created_at": "2026-10-01 09:30:12.482193+00",
      "updated_at": "2026-10-08 09:00:31+00"
    }
  ],
  "total_records": 34,
  "next_page_url": "/v2/campaigns?page=2&limit=20",
  "previous_page_url": null
}
```

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

## Invia o programma una campagna — POST /campaigns/{id}/send

> Invia subito una campagna alle sue liste, oppure programma una campagna in bozza per una data e un’ora future.

# Invia o programma una campagna

Invia subito la campagna, oppure la programma quando passi un `scheduled_at` futuro. Richiede una chiave API con il permesso `full` e un [workspace verificato](/it/docs/workspaces/production-access/): i workspace non verificati non possono inviare campagne e ricevono `403`.

Prima di inviare, assicurati che la campagna abbia un `from_email` su un dominio verificato, un oggetto, un corpo `html` o `text` e almeno una lista inclusa (impostata con [Aggiorna una campagna](/it/docs/api-reference/campaigns/update/)). Ogni email costa 2 crediti.

`POST /campaigns/{id}/send`

## Parametri di percorso

- `id` (string, obbligatorio): L’ID della campagna (`cmp_…`) o il nome della campagna.

## Parametri del corpo

- `scheduled_at` (string): Quando inviare. Accetta ISO 8601 (`2026-10-08T09:00:00Z`), un timestamp Unix in secondi o un’espressione in linguaggio naturale come `tomorrow at 9am` (interpretata in UTC). L’orario deve essere nel futuro e la campagna deve essere `draft`. Omettilo per inviare subito. Per inviare in anticipo una campagna programmata, chiama questo endpoint senza `scheduled_at`.

## Restituisce

**Invio immediato:** lo stato passa a `sending` ed Emailit genera `campaign.sending`. Emailit crea poi un’email per ogni destinatario: ogni contatto iscritto alle liste incluse, senza duplicati di indirizzo, esclusi i contatti disiscritti e gli indirizzi soppressi. Quando tutti i destinatari sono stati passati alla pipeline di invio, lo stato diventa `sent` ed Emailit genera `campaign.sent`. Segui la consegna nel pannello o con gli [eventi delle email](/it/docs/webhooks/event-types/).

**Programmazione:** lo stato passa a `scheduled` ed Emailit genera `campaign.scheduled`. All’orario programmato la campagna diventa `queued` (`campaign.queued`) e poi viene inviata come descritto sopra.

La risposta contiene `object`, `id`, `name` e il nuovo `status`, più `scheduled_at` quando programmi.

| Stato | Quando |
| --- | --- |
| `403` | Il workspace non è verificato, oppure la chiave API non ha il permesso `full`. |
| `404` | Nessuna campagna corrisponde a `id`. |
| `422` | `scheduled_at` non può essere interpretato o non è nel futuro, oppure hai cercato di programmare una campagna che non è una bozza. |

**Richiesta** `POST /campaigns/{id}/send`

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/campaigns/cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN/send \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "scheduled_at": "2026-10-08T09:00:00Z" }'
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/campaigns/cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN/send', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.EMAILIT_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ scheduled_at: '2026-10-08T09:00:00Z' }),
});
const campaign = await res.json();
```

**Python**

```python
import os, requests

r = requests.post(
    "https://api.emailit.com/v2/campaigns/cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN/send",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    json={"scheduled_at": "2026-10-08T09:00:00Z"},
)
campaign = r.json()
```

**PHP**

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

$response = $client->post('campaigns/cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN/send', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'json' => ['scheduled_at' => '2026-10-08T09:00:00Z'],
]);
$campaign = json_decode($response->getBody(), true);
```

**200 scheduled**

```json
{
  "object": "campaign",
  "id": "cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN",
  "name": "October newsletter",
  "status": "scheduled",
  "scheduled_at": "2026-10-08T09:00:00.000000Z"
}
```

**200 sending**

```json
{
  "object": "campaign",
  "id": "cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN",
  "name": "October newsletter",
  "status": "sending"
}
```

**403**

```json
{
  "code": "unverified_workspace_recipient",
  "error": "Workspace not verified",
  "message": "Unverified workspaces cannot send campaigns. You can send individual emails only to workspace members' account emails."
}
```

**422**

```json
{
  "error": "Campaign cannot be scheduled",
  "message": "Campaign status is 'sent'. Only draft campaigns can be scheduled."
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/campaigns/send/

## Annulla una campagna — POST /campaigns/{id}/cancel

> Annulla una campagna in bozza o in fase di invio. Le email già in coda per la consegna non vengono richiamate.

# Annulla una campagna

Imposta lo stato della campagna su `canceled` e genera un evento `campaign.canceled`. Richiede una chiave API con il permesso `full`.

Puoi annullare solo le campagne con stato `draft` o `sending`; qualsiasi altro stato restituisce `422`. Annullare una campagna in fase di invio non richiama le email già in coda per la consegna.

`POST /campaigns/{id}/cancel`

## Parametri di percorso

- `id` (string, obbligatorio): L’ID della campagna (`cmp_…`) o il nome della campagna.

## Restituisce

Restituisce `object`, `id`, `name` e `status` (`canceled`).

Restituisce `422` se lo stato della campagna non è `draft` o `sending`, e `404` se la campagna non esiste.

**Richiesta** `POST /campaigns/{id}/cancel`

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/campaigns/cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN/cancel \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/campaigns/cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN/cancel', {
  method: 'POST',
  headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` },
});
const campaign = await res.json();
```

**Python**

```python
import os, requests

r = requests.post(
    "https://api.emailit.com/v2/campaigns/cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN/cancel",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
)
campaign = r.json()
```

**PHP**

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

$response = $client->post('campaigns/cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN/cancel', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
]);
$campaign = json_decode($response->getBody(), true);
```

**200**

```json
{
  "object": "campaign",
  "id": "cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN",
  "name": "October newsletter",
  "status": "canceled"
}
```

**422**

```json
{
  "error": "Campaign cannot be canceled",
  "message": "Campaign status is 'scheduled'. Only 'draft' or 'sending' campaigns can be canceled."
}
```

**404**

```json
{
  "error": "Campaign not found"
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/campaigns/cancel/

## Elimina una campagna — DELETE /campaigns/{id}

> Elimina definitivamente una campagna tramite ID o nome. Genera un evento campaign.deleted; le email già inviate non vengono toccate.

# Elimina una campagna

Elimina definitivamente una campagna. Richiede una chiave API con il permesso `full`. Genera un evento `campaign.deleted`.

L’eliminazione di una campagna non influisce sulle email già inviate o in coda. Per fermare una campagna in fase di invio, prima [annullala](/it/docs/api-reference/campaigns/cancel/).

`DELETE /campaigns/{id}`

## Parametri di percorso

- `id` (string, obbligatorio): L’ID della campagna (`cmp_…`) o il nome della campagna.

## Restituisce

Restituisce `object`, `id`, `name` e `deleted: true`. Restituisce `404` se la campagna non esiste.

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

**cURL**

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

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/campaigns/cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN', {
  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/campaigns/cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN",
    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('campaigns/cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
]);
$result = json_decode($response->getBody(), true);
```

**200**

```json
{
  "object": "campaign",
  "id": "cmp_3zNrBaNjAoPK1l0IL2GQ3pDkubN",
  "name": "October newsletter",
  "deleted": true
}
```

**404**

```json
{
  "error": "Campaign not found"
}
```

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