# Template API

> Crea versioni dei template, pubblicane una per alias e usale per inviare.

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

## Crea un template — POST /templates

> Crea una versione di un template sotto un alias. Un nuovo alias viene pubblicato subito; una versione per un alias esistente parte come bozza non pubblicata.

# Crea un template

Crea una versione di un template. Le versioni che condividono un `alias` appartengono allo stesso template, e per ogni alias è pubblicata una sola versione alla volta. Quando [invii un’email](/it/docs/api-reference/emails/send/) con `template` impostato su un alias, Emailit usa la versione pubblicata. Richiede una chiave API con il permesso `full`.

`POST /templates`

## Corpo della richiesta

- `name` (string, obbligatorio): Nome del template mostrato nel pannello. Fino a 191 caratteri.

- `alias` (string, obbligatorio): Identificatore che raggruppa le versioni di un template. Fino a 191 caratteri; solo lettere minuscole, numeri, trattini bassi e trattini (`^[a-z0-9_-]+$`). Se nessun template usa ancora questo alias, la nuova versione viene pubblicata subito. Se l’alias esiste già, la nuova versione viene creata non pubblicata (`published_at` è `null`) e la pubblichi con [Pubblica un template](/it/docs/api-reference/templates/publish/).

- `from` (string): Mittente predefinito, ad esempio `Acme <hello@acme.com>`. Fino a 191 caratteri.

- `subject` (string): Riga dell’oggetto predefinita. Fino a 191 caratteri. Può contenere variabili [Temple](/it/docs/templates/temple/) come `{{ first_name }}`.

- `reply_to` (string | string[]): Indirizzo di risposta (Reply-To), oppure un array di indirizzi. Ogni valore deve essere un indirizzo email valido.

- `html` (string): Corpo HTML.

- `text` (string): Corpo in testo semplice.

- `source` (string): Documento sorgente dell’editor, ad esempio il JSON Dragit di un template creato nell’editor drag and drop. Viene salvato così com’è. Con `editor: "mjml"`, contiene l’MJML: Emailit lo convalida, lo memorizza come [documento MJML](/it/docs/templates/mjml/#the-stored-document) e lo compila in `html`.

- `editor` (string): Editor a cui appartiene il template: `html` (predefinito), `text`, `dragit` o `tiptap`. `mjml` è in alpha e aperto solo al team di Emailit; le altre richieste ricevono `403` con `error: "mjml_alpha"`. Vedi [Editor e API MJML](/it/docs/templates/mjml/).

## Restituisce

Restituisce `201 Created` con il template in `data` e un `message` di conferma. Il template include `html`, `text` e `source`. Emailit invia anche un evento webhook [`template.created`](/it/docs/webhooks/events/template/created/).

I template MJML restituiscono anche un oggetto `mjml` con le versioni del documento. Un MJML non valido restituisce `422` con `errors.source` e `diagnostics`; vedi [Convalida](/it/docs/templates/mjml/#validation).

Se un campo non supera la convalida, la risposta è `400` con `message: "Validation failed"` e un oggetto `errors` organizzato per campo, ad esempio per un alias con lettere maiuscole o un indirizzo `reply_to` non valido. Se invece mancano `name` o `alias`, o se il valore di `editor` non è consentito, viene restituito l’errore di convalida standard `400` con un array `details`. Vedi [Errori](/it/docs/api-reference/errors/).

**Richiesta** `POST /templates`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const template = await emailit.templates.create({
  name: 'Welcome email',
  alias: 'welcome-email',
  subject: 'Welcome to Acme, {{ first_name }}',
  html: '<h1>Welcome, {{ first_name }}</h1>'
});
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

template = client.templates.create({
    "name": "Welcome email",
    "alias": "welcome-email",
    "subject": "Welcome to Acme, {{ first_name }}",
    "html": "<h1>Welcome, {{ first_name }}</h1>"
})
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$template = $emailit->templates()->create([
    'name' => 'Welcome email',
    'alias' => 'welcome-email',
    'subject' => 'Welcome to Acme, {{ first_name }}',
    'html' => '<h1>Welcome, {{ first_name }}</h1>'
]);
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

template = client.templates.create(
  name: "Welcome email",
  alias: "welcome-email",
  subject: "Welcome to Acme, {{ first_name }}",
  html: "<h1>Welcome, {{ first_name }}</h1>"
)
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

template, err := client.Templates.Create(&emailit.CreateTemplateRequest{
    Name:    "Welcome email",
    Alias:   "welcome-email",
    Subject: "Welcome to Acme, {{ first_name }}",
    Html:    "<h1>Welcome, {{ first_name }}</h1>",
})
```

**Rust**

```rust
use emailit::Emailit;
let emailit = Emailit::new("your_api_key");

let template = emailit.templates.create(
    emailit::types::CreateTemplateParams::new("Welcome email")
        .with_subject("Welcome to Acme, {{ first_name }}")
        .with_html("<h1>Welcome, {{ first_name }}</h1>")
).await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;
EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject template = emailit.templates().create(
    TemplateCreateParams.builder()
        .setName("Welcome email")
        .setAlias("welcome-email")
        .setSubject("Welcome to Acme, {{ first_name }}")
        .setHtml("<h1>Welcome, {{ first_name }}</h1>")
        .build()
);
```

**.NET**

```csharp
using Emailit;
var emailit = new EmailitClient("your_api_key");

var template = emailit.Templates.Create(new TemplateCreateOptions {
    Name = "Welcome email",
    Alias = "welcome-email",
    Subject = "Welcome to Acme, {{ first_name }}",
    Html = "<h1>Welcome, {{ first_name }}</h1>"
});
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$template = Emailit::templates()->create([
    'name' => 'Welcome email',
    'alias' => 'welcome-email',
    'subject' => 'Welcome to Acme, {{ first_name }}',
    'html' => '<h1>Welcome, {{ first_name }}</h1>'
]);
```

**cURL**

```bash
curl https://api.emailit.com/v2/templates \
  -H "Authorization: Bearer your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Welcome email",
    "alias": "welcome-email",
    "subject": "Welcome to Acme, {{ first_name }}",
    "html": "<h1>Welcome, {{ first_name }}</h1>"
  }'
```

**201**

```json
{
  "data": {
    "id": "tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a",
    "name": "Welcome email",
    "alias": "welcome-email",
    "from": null,
    "subject": "Welcome to Acme, {{ first_name }}",
    "reply_to": null,
    "html": "<h1>Welcome, {{ first_name }}</h1>",
    "text": null,
    "source": null,
    "editor": "html",
    "published_at": "2026-09-30T10:30:00.482119Z",
    "preview_url": null,
    "created_at": "2026-09-30T10:30:00.482119Z",
    "updated_at": "2026-09-30T10:30:00.482119Z"
  },
  "message": "Template was successfully created."
}
```

**400**

```json
{
  "message": "Validation failed",
  "errors": {
    "alias": ["Alias must contain only lowercase letters (a-z), numbers (0-9), underscores (_), and hyphens (-)"]
  }
}
```

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

## Recupera un template — GET /templates/{id}

> Recupera una versione di un template tramite ID con il contenuto completo, più un riepilogo di tutte le altre versioni che condividono il suo alias.

# Recupera un template

Restituisce una versione di un template, compreso il contenuto, ed elenca le altre versioni dello stesso alias in `versions`. I template si cercano solo per ID, non per alias. Richiede una chiave API con il permesso `full`.

`GET /templates/:id`

## Parametri di percorso

- `id` (string, obbligatorio): ID del template, ad esempio `tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a`.

## Restituisce

Restituisce `200 OK` con il template in `data`. Oltre ai campi del template, la risposta contiene un array `versions` con `id`, `name`, `published_at`, `created_at` e `updated_at` di tutte le altre versioni che condividono l’alias, a partire dalla più recente. La versione pubblicata è quella con `published_at` diverso da null.

Restituisce `404` con `message: "Template not found"` se l’ID non esiste nel workspace.

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

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const template = await emailit.templates.get('tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a');
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

template = client.templates.get("tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a")
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$template = $emailit->templates()->get('tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a');
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

template = client.templates.get("tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a")
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

template, err := client.Templates.Get("tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a")
```

**Rust**

```rust
use emailit::Emailit;
let emailit = Emailit::new("your_api_key");

let template = emailit.templates.get("tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a").await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;
EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject template = emailit.templates().get("tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a");
```

**.NET**

```csharp
using Emailit;
var emailit = new EmailitClient("your_api_key");

var template = emailit.Templates.Get("tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a");
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$template = Emailit::templates()->get('tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a');
```

**cURL**

```bash
curl https://api.emailit.com/v2/templates/tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a \
  -H "Authorization: Bearer your_api_key"
```

**200**

```json
{
  "data": {
    "id": "tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a",
    "name": "Welcome email",
    "alias": "welcome-email",
    "from": "Acme <hello@acme.com>",
    "subject": "Welcome to Acme, {{ first_name }}",
    "reply_to": ["support@acme.com"],
    "html": "<h1>Welcome, {{ first_name }}</h1>",
    "text": "Welcome, {{ first_name }}",
    "source": null,
    "editor": "html",
    "published_at": "2026-09-30T10:30:00.482119Z",
    "preview_url": null,
    "created_at": "2026-09-28T08:12:45.103882Z",
    "updated_at": "2026-09-30T10:30:00.482119Z",
    "versions": [
      {
        "id": "tem_2xKyB4qLm7RtV9sNd3HwEa6uC1f",
        "name": "Welcome email (October)",
        "published_at": null,
        "created_at": "2026-09-30T14:02:11.550731Z",
        "updated_at": "2026-09-30T14:02:11.550731Z"
      }
    ]
  }
}
```

**404**

```json
{
  "message": "Template not found"
}
```

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

## Aggiorna un template — POST /templates/{id}

> Aggiorna il nome, l’alias, il mittente, l’oggetto o il contenuto di una versione di un template. L’aggiornamento non la pubblica né la ritira mai.

# Aggiorna un template

Aggiorna una versione di un template. Invia solo i campi che vuoi modificare. La versione mantiene il suo stato di pubblicazione: una versione pubblicata resta pubblicata e una bozza resta una bozza. Richiede una chiave API con il permesso `full`.

`POST /templates/:id`

## Parametri di percorso

- `id` (string, obbligatorio): ID del template, ad esempio `tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a`.

## Corpo della richiesta

- `name` (string): Nome del template. Fino a 191 caratteri.

- `alias` (string): Nuovo alias. Fino a 191 caratteri; solo lettere minuscole, numeri, trattini bassi e trattini. Non può essere un alias già usato da un altro template.

- `from` (string): Mittente predefinito, ad esempio `Acme <hello@acme.com>`. Fino a 191 caratteri. Invia una stringa vuota per cancellarlo.

- `subject` (string): Riga dell’oggetto predefinita. Fino a 191 caratteri. Invia una stringa vuota per cancellarla.

- `reply_to` (string | string[]): Indirizzo di risposta (Reply-To) o array di indirizzi. Invia una stringa vuota per cancellarlo.

- `html` (string): Corpo HTML.

- `text` (string): Corpo in testo semplice.

- `source` (string): Documento sorgente dell’editor, ad esempio il JSON Dragit. Per un template MJML, l’MJML completo: Emailit lo convalida e ricompila `html`, e qualsiasi `html` che invii viene ignorato.

- `editor` (string): `html`, `text`, `dragit` o `tiptap`. `mjml` è in alpha e aperto solo al team di Emailit; senza accesso a MJML, modificare il contenuto di un template MJML restituisce `403` con `error: "mjml_alpha"`. Rinominarlo o pubblicarlo funziona per tutti. Vedi [Editor e API MJML](/it/docs/templates/mjml/).

## Restituisce

Restituisce `200 OK` con il template aggiornato in `data` e un `message` di conferma. Emailit invia anche un evento webhook [`template.updated`](/it/docs/webhooks/events/template/updated/).

Restituisce `400` con `message: "Validation failed"` e un oggetto `errors` quando un valore non è valido, ad esempio `"Alias already exists"`. I valori più lunghi di 191 caratteri o un `editor` sconosciuto restituiscono l’errore di convalida standard `400`. Restituisce `404` se il template non esiste.

Per fare in modo che questa versione sia quella usata per gli invii, chiama [Pubblica un template](/it/docs/api-reference/templates/publish/).

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

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const template = await emailit.templates.update('tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a', {
  subject: 'Welcome aboard, {{ first_name }}'
});
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

template = client.templates.update("tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a", {
    "subject": "Welcome aboard, {{ first_name }}"
})
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$template = $emailit->templates()->update('tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a', [
    'subject' => 'Welcome aboard, {{ first_name }}'
]);
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

template = client.templates.update("tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a", subject: "Welcome aboard, {{ first_name }}")
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

template, err := client.Templates.Update("tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a", &emailit.UpdateTemplateRequest{
    Subject: "Welcome aboard, {{ first_name }}",
})
```

**Rust**

```rust
use emailit::Emailit;
let emailit = Emailit::new("your_api_key");

let template = emailit.templates.update("tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a",
    emailit::types::UpdateTemplateParams {
        subject: Some("Welcome aboard, {{ first_name }}".into()),
        ..Default::default()
    }
).await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;
EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject template = emailit.templates().update("tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a",
    TemplateUpdateParams.builder()
        .setSubject("Welcome aboard, {{ first_name }}")
        .build()
);
```

**.NET**

```csharp
using Emailit;
var emailit = new EmailitClient("your_api_key");

var template = emailit.Templates.Update("tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a", new TemplateUpdateOptions {
    Subject = "Welcome aboard, {{ first_name }}"
});
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$template = Emailit::templates()->update('tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a', [
    'subject' => 'Welcome aboard, {{ first_name }}'
]);
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/templates/tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a \
  -H "Authorization: Bearer your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"subject": "Welcome aboard, {{ first_name }}"}'
```

**200**

```json
{
  "data": {
    "id": "tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a",
    "name": "Welcome email",
    "alias": "welcome-email",
    "from": "Acme <hello@acme.com>",
    "subject": "Welcome aboard, {{ first_name }}",
    "reply_to": ["support@acme.com"],
    "html": "<h1>Welcome, {{ first_name }}</h1>",
    "text": "Welcome, {{ first_name }}",
    "source": null,
    "editor": "html",
    "published_at": "2026-09-30T10:30:00.482119Z",
    "preview_url": null,
    "created_at": "2026-09-28T08:12:45.103882Z",
    "updated_at": "2026-10-01T09:15:27.640000Z"
  },
  "message": "Template was successfully updated."
}
```

**400**

```json
{
  "message": "Validation failed",
  "errors": {
    "alias": ["Alias already exists"]
  }
}
```

**404**

```json
{
  "message": "Template not found"
}
```

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

## Elenca i template — GET /templates

> Elenca la versione pubblicata di ogni template del workspace, con filtri, ordinamento e paginazione per pagine.

# Elenca i template

Restituisce la versione pubblicata di ogni template, a partire dalla più recente. Le versioni non pubblicate non sono elencate; [recupera un template](/it/docs/api-reference/templates/get/) per vedere tutte le versioni del suo alias. Richiede una chiave API con il permesso `full`.

`GET /templates`

## Parametri di query

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

- `per_page` (integer): Template per pagina, da `1` a `100`. Il valore predefinito è `25`.

- `include_content` (boolean): Impostalo su `true` per includere `html`, `text` e `source` in ogni template. Per impostazione predefinita sono omessi, per mantenere leggere le risposte.

- `filter[name]` (string): Corrispondenza parziale sul nome o sull’alias del template, senza distinzione tra maiuscole e minuscole.

- `filter[alias]` (string): Alias esatto.

- `filter[editor]` (string): Editor: `html`, `text`, `dragit`, `tiptap` o `mjml` ([alpha](/it/docs/templates/mjml/)).

- `match` (string): `all` (predefinito) richiede che corrispondano tutti i filtri `key.condition`. Con `or` basta che ne corrisponda uno. Vedi [Filtri e ordinamento](/it/docs/api-reference/filtering/).

- `sort` (string): Chiave di ordinamento: `name`, `alias`, `created_at` (predefinito), `updated_at` o `published_at`.

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

## Filtri

Chiavi di filtro e di ordinamento: vedi [Filtri e ordinamento](https://emailit.com/it/docs/api-reference/filtering/).

In questo endpoint, `order` accetta solo `asc` o `desc`. Passa la chiave di ordinamento in `sort`, ad esempio `sort=name&order=asc`.

## Restituisce

Restituisce `200 OK` con i template in `data` e i campi di paginazione `total_records`, `per_page`, `current_page` e `total_pages`. Ogni template include `total_versions`, il numero di versioni che condividono il suo alias.

**Richiesta** `GET /templates`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const templates = await emailit.templates.list();
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

templates = client.templates.list()
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$templates = $emailit->templates()->list();
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

templates = client.templates.list
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

templates, err := client.Templates.List(nil)
```

**Rust**

```rust
use emailit::Emailit;
let emailit = Emailit::new("your_api_key");

let templates = emailit.templates.list(None).await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;
EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject templates = emailit.templates().list();
```

**.NET**

```csharp
using Emailit;
var emailit = new EmailitClient("your_api_key");

var templates = emailit.Templates.List();
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$templates = Emailit::templates()->list();
```

**cURL**

```bash
curl https://api.emailit.com/v2/templates \
  -H "Authorization: Bearer your_api_key"
```

**200**

```json
{
  "data": [
    {
      "id": "tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a",
      "name": "Welcome email",
      "alias": "welcome-email",
      "from": "Acme <hello@acme.com>",
      "subject": "Welcome to Acme, {{ first_name }}",
      "reply_to": ["support@acme.com"],
      "editor": "html",
      "published_at": "2026-09-30T10:30:00.482119Z",
      "preview_url": null,
      "total_versions": 3,
      "created_at": "2026-09-28T08:12:45.103882Z",
      "updated_at": "2026-09-30T10:30:00.482119Z"
    }
  ],
  "total_records": 1,
  "per_page": 25,
  "current_page": 1,
  "total_pages": 1
}
```

**401**

```json
{
  "statusCode": 401,
  "error": "Unauthorized",
  "message": "Invalid API key"
}
```

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

## Pubblica un template — POST /templates/{id}/publish

> Pubblica una versione di un template perché gli invii che usano il suo alias la utilizzino. Tutte le altre versioni dell’alias vengono ritirate contemporaneamente.

# Pubblica un template

Pubblica una versione di un template e ritira tutte le altre versioni con lo stesso alias, in un’unica transazione. Usalo per mettere in produzione una nuova bozza o per tornare a una versione precedente. Richiede una chiave API con il permesso `full`.

`POST /templates/:id/publish`

## Parametri di percorso

- `id` (string, obbligatorio): ID della versione da pubblicare, ad esempio `tem_2xKyB4qLm7RtV9sNd3HwEa6uC1f`.

## Corpo della richiesta

Nessun corpo. Pubblicare una versione già pubblicata imposta un nuovo `published_at`.

## Restituisce

Restituisce `200 OK` con il template pubblicato in `data` e un `message` di conferma. Restituisce `404` se il template non esiste.

Emailit invia un evento webhook [`template.updated`](/it/docs/webhooks/events/template/updated/) per la versione che hai pubblicato e uno per ogni versione ritirata.

**Richiesta** `POST /templates/{id}/publish`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const template = await emailit.templates.publish('tem_2xKyB4qLm7RtV9sNd3HwEa6uC1f');
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

template = client.templates.publish("tem_2xKyB4qLm7RtV9sNd3HwEa6uC1f")
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$template = $emailit->templates()->publish('tem_2xKyB4qLm7RtV9sNd3HwEa6uC1f');
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

template = client.templates.publish("tem_2xKyB4qLm7RtV9sNd3HwEa6uC1f")
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

template, err := client.Templates.Publish("tem_2xKyB4qLm7RtV9sNd3HwEa6uC1f")
```

**Rust**

```rust
use emailit::Emailit;
let emailit = Emailit::new("your_api_key");

let template = emailit.templates.publish("tem_2xKyB4qLm7RtV9sNd3HwEa6uC1f").await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;
EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject template = emailit.templates().publish("tem_2xKyB4qLm7RtV9sNd3HwEa6uC1f");
```

**.NET**

```csharp
using Emailit;
var emailit = new EmailitClient("your_api_key");

var template = emailit.Templates.Publish("tem_2xKyB4qLm7RtV9sNd3HwEa6uC1f");
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$template = Emailit::templates()->publish('tem_2xKyB4qLm7RtV9sNd3HwEa6uC1f');
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/templates/tem_2xKyB4qLm7RtV9sNd3HwEa6uC1f/publish \
  -H "Authorization: Bearer your_api_key"
```

**200**

```json
{
  "data": {
    "id": "tem_2xKyB4qLm7RtV9sNd3HwEa6uC1f",
    "name": "Welcome email (October)",
    "alias": "welcome-email",
    "from": "Acme <hello@acme.com>",
    "subject": "Welcome to Acme, {{ first_name }}",
    "reply_to": ["support@acme.com"],
    "html": "<h1>Welcome, {{ first_name }}</h1><p>Here is your October guide.</p>",
    "text": "Welcome, {{ first_name }}. Here is your October guide.",
    "source": null,
    "editor": "html",
    "published_at": "2026-10-01T09:20:04.118502Z",
    "preview_url": null,
    "created_at": "2026-09-30T14:02:11.550731Z",
    "updated_at": "2026-10-01T09:20:04.118000Z"
  },
  "message": "Template was successfully published."
}
```

**404**

```json
{
  "message": "Template not found"
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/templates/publish/

## Elimina un template — DELETE /templates/{id}

> Elimina definitivamente una versione di un template. Se elimini la versione pubblicata, il suo alias resta senza un template pubblicato.

# Elimina un template

Elimina definitivamente una versione di un template. Le altre versioni dello stesso alias vengono mantenute. Richiede una chiave API con il permesso `full`.

`DELETE /templates/:id`

## Parametri di percorso

- `id` (string, obbligatorio): ID del template, ad esempio `tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a`.

## Restituisce

Restituisce `200 OK` con `data: null` e un `message` di conferma. Emailit invia un evento webhook [`template.deleted`](/it/docs/webhooks/events/template/deleted/) con la versione eliminata. Restituisce `404` se il template non esiste.

Se elimini la versione pubblicata, nessuna versione di quell’alias risulta pubblicata finché non ne [pubblichi un’altra](/it/docs/api-reference/templates/publish/), e gli invii con quell’alias non riescono. L’eliminazione di una bozza non influisce sulla versione pubblicata. L’eliminazione non si può annullare.

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

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

await emailit.templates.delete('tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a');
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

client.templates.delete("tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a")
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$emailit->templates()->delete('tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a');
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

client.templates.delete("tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a")
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

err := client.Templates.Delete("tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a")
```

**Rust**

```rust
use emailit::Emailit;
let emailit = Emailit::new("your_api_key");

emailit.templates.delete("tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a").await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;
EmailitClient emailit = new EmailitClient("your_api_key");

emailit.templates().delete("tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a");
```

**.NET**

```csharp
using Emailit;
var emailit = new EmailitClient("your_api_key");

emailit.Templates.Delete("tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a");
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

Emailit::templates()->delete('tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a');
```

**cURL**

```bash
curl -X DELETE https://api.emailit.com/v2/templates/tem_2xKx7M2c9wQe3kHhJ8sVtY1pZ0a \
  -H "Authorization: Bearer your_api_key"
```

**200**

```json
{
  "data": null,
  "message": "Template was successfully deleted."
}
```

**404**

```json
{
  "message": "Template not found"
}
```

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