# Invia la prima email con l’API

> Verifica un dominio, crea una chiave API e invia la prima email con cURL o con un SDK ufficiale per Node.js, Python, PHP, Ruby, Go, Java, .NET o Rust.

Con questo avvio rapido passi da un account nuovo a un’email consegnata in circa cinque minuti, più il tempo che serve al tuo provider DNS per pubblicare i record. Verificherai un dominio, creerai una chiave API, invierai un’email e la ritroverai nel pannello.

## Prima di iniziare

- Un account Emailit. Registrati su [dash.emailit.com](https://dash.emailit.com).
- Un dominio a cui puoi aggiungere record DNS, come `acme.com`. Puoi usare anche un sottodominio, come `mail.acme.com`.

## Aggiungi e verifica il dominio

Emailit invia solo dai domini che hai verificato, così i server di posta dei destinatari possono controllare che l’email provenga davvero da te.

1. **Aggiungi il dominio.** Vai a **Email API → Domains**, seleziona **Add domain**, inserisci `acme.com` e seleziona **Create**.

2. **Pubblica i record DNS.** La pagina del dominio elenca i record da aggiungere presso il tuo provider DNS. Copia i valori esatti da quella pagina. I tre record obbligatori hanno questo aspetto:

   | Tipo | Nome | Valore |
   | --- | --- | --- |
   | TXT | `emailit._domainkey.acme.com` | `v=DKIM1; t=s; h=sha256; p=…` (la tua chiave) |
   | TXT | `emailit.acme.com` | `v=spf1 include:_spf.emailit.com ~all` |
   | MX | `emailit.acme.com`, priorità 10 | `feedback-smtp.ffdc-1.emailit.com` |

   Se i tuoi DNS sono su Cloudflare, puoi invece pubblicare i record con un clic. Vedi [Cloudflare](/it/docs/domains/cloudflare/).

3. **Controlla i DNS.** Seleziona **Check DNS**. Quando SPF, DKIM e Return Path mostrano **OK**, il dominio risulta **Verified**. La maggior parte dei provider pubblica i record in pochi minuti, ma possono servire fino a 48 ore.

Con Pay as you go, un dominio registrato da meno di 30 giorni mostra **Pending verification** finché il team di Emailit non lo esamina. Per i dettagli e i record facoltativi per DMARC, tracciamento ed email in entrata, vedi [Aggiungi un dominio](/it/docs/domains/add-a-domain/).

## Crea una chiave API

1. **Apri le chiavi API.** Vai a **Email API → API Keys** e seleziona **Add API key**.

2. **Dai un nome alla chiave e scegli un permesso.** Inserisci un nome come `Quickstart`. **Sending Only** può solo inviare email. **Full Access** può chiamare anche il resto dell’API. Per questo avvio rapido va bene l’uno o l’altro.

3. **Copia la chiave.** Seleziona **Create** e copia la chiave. Inizia con `secret_` e viene mostrata una sola volta.

4. **Salvala in una variabile d’ambiente**, così resta fuori dal codice:

```bash
export EMAILIT_API_KEY="secret_••••"
```

## Invia un’email

Installa l’SDK per il tuo linguaggio, oppure usa cURL:

**cURL**

```bash
# cURL is preinstalled on macOS, Linux and Windows 10 or later
curl --version
```

**Node.js**

```bash
npm install @emailit/node
```

**Python**

```bash
pip install emailit
```

**PHP**

```bash
composer require emailit/emailit-php
```

**Laravel**

```bash
composer require emailit/emailit-laravel
# Then add EMAILIT_API_KEY=secret_•••• to your .env file
```

**Ruby**

```bash
gem install emailit
```

**Go**

```bash
go get github.com/emailit/emailit-go/v2
```

**Java**

```xml
<dependency>
  <groupId>com.emailit</groupId>
  <artifactId>emailit-java</artifactId>
  <version><!-- latest version from Maven Central --></version>
</dependency>
```

**.NET**

```bash
dotnet add package Emailit
```

**Rust**

```bash
cargo add emailit
cargo add tokio --features full
```

Poi invia un’email. Usa un indirizzo From del dominio che hai verificato e inviala all’indirizzo email con cui ti sei registrato:

**cURL**

```bash
curl https://api.emailit.com/v2/emails \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "from": "Acme <hello@acme.com>",
    "to": "ada@example.com",
    "subject": "Hello from Emailit",
    "html": "<p>This is my first email sent with Emailit.</p>"
  }'
```

**Node.js**

```javascript
import { Emailit } from '@emailit/node';

const emailit = new Emailit(process.env.EMAILIT_API_KEY);

const email = await emailit.emails.send({
  from: 'Acme <hello@acme.com>',
  to: 'ada@example.com',
  subject: 'Hello from Emailit',
  html: '<p>This is my first email sent with Emailit.</p>',
});

console.log(email.id, email.status);
```

**Python**

```python
import os
from emailit import EmailitClient

client = EmailitClient(os.environ["EMAILIT_API_KEY"])

email = client.emails.send({
    "from": "Acme <hello@acme.com>",
    "to": "ada@example.com",
    "subject": "Hello from Emailit",
    "html": "<p>This is my first email sent with Emailit.</p>",
})

print(email.id, email.status)
```

**PHP**

```php
<?php
require 'vendor/autoload.php';

$emailit = Emailit::client(getenv('EMAILIT_API_KEY'));

$email = $emailit->emails()->send([
    'from' => 'Acme <hello@acme.com>',
    'to' => 'ada@example.com',
    'subject' => 'Hello from Emailit',
    'html' => '<p>This is my first email sent with Emailit.</p>',
]);

echo $email->id . ' ' . $email->status;
```

**Laravel**

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

$email = Emailit::emails()->send([
    'from' => 'Acme <hello@acme.com>',
    'to' => 'ada@example.com',
    'subject' => 'Hello from Emailit',
    'html' => '<p>This is my first email sent with Emailit.</p>',
]);

logger()->info('Sent email', ['id' => $email->id]);
```

**Ruby**

```ruby
require "emailit"

client = Emailit::EmailitClient.new(ENV["EMAILIT_API_KEY"])

email = client.emails.send(
  from: "Acme <hello@acme.com>",
  to: "ada@example.com",
  subject: "Hello from Emailit",
  html: "<p>This is my first email sent with Emailit.</p>"
)

puts email.id, email.status
```

**Go**

```go
package main

import (
    "fmt"
    "os"

    "github.com/emailit/emailit-go/v2"
)

func main() {
    client := emailit.NewClient(os.Getenv("EMAILIT_API_KEY"))

    email, err := client.Emails.Send(&emailit.SendEmailRequest{
        From:    "Acme <hello@acme.com>",
        To:      []string{"ada@example.com"},
        Subject: "Hello from Emailit",
        Html:    "<p>This is my first email sent with Emailit.</p>",
    })
    if err != nil {
        panic(err)
    }

    fmt.Println(email.Id)
}
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;
import java.util.List;

public class SendEmail {
    public static void main(String[] args) throws Exception {
        EmailitClient emailit = new EmailitClient(System.getenv("EMAILIT_API_KEY"));

        EmailitObject email = emailit.emails().send(
            EmailSendParams.builder()
                .setFrom("Acme <hello@acme.com>")
                .setTo(List.of("ada@example.com"))
                .setSubject("Hello from Emailit")
                .setHtml("<p>This is my first email sent with Emailit.</p>")
                .build()
        );

        System.out.println(email.getString("id"));
    }
}
```

**.NET**

```csharp
using Emailit;
using Emailit.Options;
using Emailit.Resources;

var emailit = new EmailitClient(Environment.GetEnvironmentVariable("EMAILIT_API_KEY"));

Email email = emailit.Emails.Send(new EmailSendOptions
{
    From = "Acme <hello@acme.com>",
    To = new[] { "ada@example.com" },
    Subject = "Hello from Emailit",
    Html = "<p>This is my first email sent with Emailit.</p>",
});

Console.WriteLine($"{email.Id} {email.Status}");
```

**Rust**

```rust
use emailit::types::CreateEmailBaseOptions;
use emailit::{Emailit, Result};

#[tokio::main]
async fn main() -> Result<()> {
    let api_key = std::env::var("EMAILIT_API_KEY").expect("EMAILIT_API_KEY is not set");
    let emailit = Emailit::new(&api_key);

    let email = CreateEmailBaseOptions::new(
        "Acme <hello@acme.com>",
        ["ada@example.com"],
        "Hello from Emailit",
    )
    .with_html("<p>This is my first email sent with Emailit.</p>");

    let result = emailit.emails.send(email).await?;
    println!("{:?}", result.id);

    Ok(())
}
```

> **Modalità sandbox:** Finché il workspace non ha l’accesso alla produzione, puoi inviare solo agli indirizzi email degli account dei membri del workspace. L’invio a chiunque altro restituisce `403` con il codice `unverified_workspace_recipient`. Quando sei pronto per i destinatari reali, [richiedi l’accesso alla produzione](/it/docs/workspaces/production-access/).

## Leggi la risposta

Una richiesta riuscita restituisce `200` con la nuova email:

```json
{
  "object": "email",
  "id": "em_2pX7cN4kQ9vLm3RtB8yWd1Zs",
  "token": "2pX7cN4m8FqT1vKz6RbL3HwYd",
  "message_id": "<2pX7cN4m8FqT1vKz6RbL3HwYd@acme.com>",
  "from": "Acme <hello@acme.com>",
  "to": ["ada@example.com"],
  "subject": "Hello from Emailit",
  "status": "accepted",
  "scheduled_at": null,
  "created_at": "2026-10-01T09:30:12.418Z",
  "tracking": { "loads": false, "clicks": false }
}
```

| Campo | Significato |
| --- | --- |
| `id` | L’ID dell’email. Usalo per cercare l’email, annullarla o ritentarla, e per associare gli eventi webhook. |
| `status` | `accepted` significa che Emailit ha messo in coda l’email per la consegna. È `scheduled` se hai impostato `scheduled_at`. |
| `message_id` | L’header `Message-ID` dell’email. |
| `ids` | Presente solo con più destinatari. Associa ogni indirizzo destinatario al proprio ID email. |
| `tracking` | Indica se per questa email vengono tracciati aperture (`loads`) e clic. Il tracciamento richiede un [sottodominio di tracciamento](/it/docs/tracking/) verificato. |

`accepted` non significa ancora consegnata. La consegna avviene in background, e lo stato cambia man mano che procede.

## Controllala nel pannello

Vai a **Email API → Emails**. L’email è in cima alla scheda **Outgoing**. Di solito, in pochi secondi il suo stato passa da **accepted** a **delivered**. Aprila per vedere gli header, il contenuto, ogni tentativo di consegna con la risposta del server ricevente e i risultati dei controlli antispam.

La richiesta stessa compare in **Email API → Logs**, con il codice di stato e i corpi della richiesta e della risposta.

## Risoluzione dei problemi

| Risposta | Causa | Soluzione |
| --- | --- | --- |
| `401` `API key required` o `Invalid API key` | L’header `Authorization` manca o la chiave è errata | Invia `Authorization: Bearer secret_…` con una chiave valida |
| `403` `unverified_workspace_recipient` | Il workspace è in modalità sandbox | Invia all’indirizzo email dell’account di un membro del workspace, oppure [richiedi l’accesso alla produzione](/it/docs/kb/403-unverified-workspace-recipient/) |
| `422` `From/Sender domain is not valid or not verified` | Il dominio From non è verificato in questo workspace | Verifica il dominio, oppure usa un indirizzo di un dominio verificato |
| `403` `Domain not authorized` | La chiave di solo invio è limitata a un dominio diverso | Usa una chiave per questo dominio, oppure una chiave senza limitazioni |
| `402` `Insufficient credits` | Il workspace non ha abbastanza crediti | [Aggiungi crediti](/it/docs/kb/402-insufficient-credits/) |
| `429` `Rate limit exceeded` | Troppe email in questo secondo o in questo giorno | Attendi il tempo indicato in `retry-after`. Vedi [Limiti di frequenza](/it/docs/kb/429-rate-limit-exceeded/). |

## Passaggi successivi

  - [Configura i webhook](/it/docs/webhooks/set-up/): Ricevi in tempo reale gli eventi di consegna, bounce e apertura.
  - [Invia con un template](/it/docs/templates/): Progetta una volta nel pannello e invia per alias con variabili.
  - [Idempotenza](/it/docs/email-api/idempotency/): Ritenta le richieste in sicurezza senza inviare due volte.
  - [Checklist per andare in produzione](/it/docs/get-started/go-live/): Cosa controllare prima di inviare a destinatari reali.

---
Fonte: https://emailit.com/it/docs/quickstart/api/