# Inviare email con Laravel

> Scopri come inviare email in Laravel con il pacchetto Emailit Laravel: si integra come transport di posta nativo e ti dà accesso completo all’API di Emailit tramite una Facade.

2026-03-04 · George (https://x.com/thegeorge, https://www.linkedin.com/in/jiri-zizka/)

Laravel offre già di serie un ottimo supporto per l’invio di email, ma ti serve comunque un servizio di consegna affidabile dietro le quinte. Il pacchetto **Emailit Laravel** si integra direttamente nel sistema mail di Laravel come transport nativo. I tuoi Mailable, Notification e chiamate `Mail::send()` esistenti funzionano senza alcuna modifica al codice. In più, hai accesso completo all’API di Emailit tramite una comoda Facade.

L’invio di email è una delle attività più comuni in qualsiasi applicazione Laravel. Conferme di registrazione utente, reset delle password, ricevute d’ordine, aggiornamenti di spedizione e newsletter di marketing dipendono tutti da una consegna email affidabile. Laravel fornisce un potente livello di astrazione per le email, ma la consegna vera e propria dipende dal transport che configuri. Un’API email come Emailit ti offre un’alta deliverability, il tracciamento delle consegne, la gestione dei bounce e analisi dettagliate, senza dover gestire server SMTP o preoccuparti della reputazione degli IP.

In questa guida ti mostreremo come configurare Emailit in un’applicazione Laravel e inviare email utilizzando sia il sistema mail standard di Laravel che la Facade di Emailit.

## Requisiti

- PHP 8.1 o superiore
- Laravel 10, 11 o 12
- Un [account Emailit](https://app.emailit.com/register) con una chiave API

## Installazione

Installa il pacchetto tramite Composer:

```bash
composer require emailit/emailit-laravel
```

Il pacchetto registra automaticamente il proprio service provider, quindi non serve alcuna registrazione manuale. Funziona subito con Laravel 10, 11 e 12.

## Configurazione

Aggiungi la tua chiave API al file `.env`:

```
EMAILIT_API_KEY=la_tua_chiave_api
```

Imposta Emailit come mailer predefinito:

```
MAIL_MAILER=emailit
```

Aggiungi il mailer `emailit` all’array mailers del tuo `config/mail.php`:

```php
'mailers' => [
    // ...

    'emailit' => [
        'transport' => 'emailit',
    ],
],
```

Se vuoi, pubblica il file di configurazione per personalizzare l’URL di base dell’API:

```bash
php artisan vendor:publish --tag=emailit-config
```

La configurazione è intenzionalmente minimale. Dopo aver impostato la chiave API e il mailer predefinito, Laravel instraderà automaticamente tutta la posta in uscita attraverso Emailit. Non è necessario configurare host SMTP, porte, impostazioni di crittografia o credenziali di autenticazione come faresti con una configurazione server mail tradizionale.

## Invio di email con Laravel Mail

Una volta completata la configurazione, tutte le funzionalità mail di Laravel funzionano subito. Il tuo codice esistente non deve cambiare.

### Con un Mailable

Crea una classe Mailable come faresti normalmente:

```php
namespace App\Mail;

use Illuminate\Bus\Queueable;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Queue\SerializesModels;

class EmailBenvenuto extends Mailable
{
    use Queueable, SerializesModels;

    public function __construct(
        public readonly User $user,
    ) {}

    public function envelope(): Envelope
    {
        return new Envelope(
            subject: 'Benvenuto nella nostra App',
        );
    }

    public function content(): Content
    {
        return new Content(
            view: 'emails.benvenuto',
        );
    }
}
```

Poi inviala:

```php
use Illuminate\Support\Facades\Mail;
use App\Mail\EmailBenvenuto;

Mail::to('utente@esempio.com')->send(new EmailBenvenuto($user));
```

Mail in coda, Mailable Markdown e Notification funzionano esattamente come ti aspetteresti. Emailit si posiziona in modo trasparente dietro il livello mail di Laravel, così puoi sostituirlo a qualsiasi transport esistente come SMTP, Mailgun o SES senza toccare il codice della tua applicazione. Questo rende facile testare Emailit insieme al tuo provider attuale o migrare gradualmente.

## Utilizzo della Facade Emailit

Per funzionalità che vanno oltre quello che offre il sistema mail di Laravel, come template con variabili, invii programmati o gestione delle risorse API, utilizza la Facade `Emailit`. Ti dà accesso diretto al completo [SDK PHP di Emailit](https://github.com/emailit/emailit-php).

### Invia un’email tramite API

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

$email = Emailit::emails()->send([
    'from'    => 'ciao@tuodominio.com',
    'to'      => ['utente@esempio.com'],
    'subject' => 'Ciao da Emailit',
    'html'    => '<h1>Benvenuto!</h1>',
]);

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

### Invia con un template

Richiama i template che hai creato nel pannello di Emailit e passa le variabili dinamiche:

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

$email = Emailit::emails()->send([
    'from'      => 'ciao@tuodominio.com',
    'to'        => 'utente@esempio.com',
    'template'  => 'email_benvenuto',
    'variables' => [
        'nome'    => 'Mario Rossi',
        'azienda' => 'Acme S.r.l.',
    ],
]);
```

Usare template lato server è un pattern potente per le applicazioni Laravel. Designer e marketer possono aggiornare contenuto, stile e layout delle email nel pannello di Emailit senza modifiche al codice né nuovi deploy. Il codice PHP deve solo passare i dati: al rendering pensa il template.

### Programma un’email

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

$email = Emailit::emails()->send([
    'from'         => 'promemoria@tuodominio.com',
    'to'           => 'utente@esempio.com',
    'subject'      => 'Promemoria Appuntamento',
    'html'         => '<p>Il tuo appuntamento è domani alle 14:00.</p>',
    'scheduled_at' => '2026-04-10T09:00:00Z',
]);
```

Le email programmate sono gestite interamente dall’API Emailit, il che significa che funzionano indipendentemente dal sistema di code di Laravel. È ideale per promemoria di appuntamenti, avvisi di rinnovo degli abbonamenti e campagne legate a una scadenza, in cui vuoi una consegna garantita a un orario preciso anche se il server della tua applicazione ha un’interruzione.

### Invia con allegati

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

$email = Emailit::emails()->send([
    'from'        => 'fatture@tuodominio.com',
    'to'          => 'cliente@esempio.com',
    'subject'     => 'La tua Fattura #12345',
    'html'        => '<p>Trovi la tua fattura in allegato.</p>',
    'attachments' => [
        [
            'filename'     => 'fattura.pdf',
            'content'      => base64_encode(file_get_contents('fattura.pdf')),
            'content_type' => 'application/pdf',
        ],
    ],
]);
```

## Gestione delle risorse

La Facade espone ogni servizio dell’API Emailit, così puoi gestire l’intera infrastruttura email da Laravel.

### Domini

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

$dominio = Emailit::domains()->create([
    'name' => 'esempio.com',
    'track_loads' => true,
    'track_clicks' => true,
]);

$dominio = Emailit::domains()->verify('sd_123');
```

Gestire i domini di invio attraverso l’API è utile per piattaforme SaaS che devono configurare domini personalizzati per ogni cliente. Puoi automatizzare l’intero workflow di verifica del dominio, inclusi i controlli dei record DNS, direttamente dalla tua applicazione Laravel.

### Contatti

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

$contatto = Emailit::contacts()->create([
    'email' => 'utente@esempio.com',
    'first_name' => 'Mario',
    'last_name' => 'Rossi',
]);

$contatti = Emailit::contacts()->list();
```

### Verifica email

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

$risultato = Emailit::emailVerifications()->verify([
    'email' => 'test@esempio.com',
]);

echo $risultato->status; // valid
echo $risultato->risk;   // low
```

Verificare gli indirizzi email al momento della registrazione o dell’invio di un modulo ti aiuta a mantenere pulita la lista dei contatti e protegge la tua reputazione di mittente. Tassi di bounce elevati dovuti a indirizzi non validi possono far finire le tue email nello spam, quindi la verifica è una best practice per qualsiasi applicazione Laravel che invia email transazionali o di marketing su larga scala.

## Dependency injection

Se preferisci non usare le Facade, puoi iniettare direttamente il client:

```php
use Emailit\EmailitClient;

class EmailController extends Controller
{
    public function send(EmailitClient $emailit)
    {
        $email = $emailit->emails()->send([
            'from'    => 'ciao@tuodominio.com',
            'to'      => ['utente@esempio.com'],
            'subject' => 'Ciao',
            'html'    => '<p>Ciao!</p>',
        ]);

        return response()->json(['id' => $email->id]);
    }
}
```

Il service container di Laravel risolve automaticamente l’istanza `EmailitClient` con la chiave API dalla tua configurazione, così ottieni la stessa comodità della Facade con i vantaggi di testabilità della dependency injection.

## Gestione degli errori

L’SDK PHP sottostante lancia eccezioni tipizzate, così puoi catturare tipi di errore specifici:

```php
use Emailit\Exceptions\AuthenticationException;
use Emailit\Exceptions\RateLimitException;
use Emailit\Exceptions\ApiErrorException;
use Emailit\Laravel\Facades\Emailit;

try {
    Emailit::emails()->send([...]);
} catch (AuthenticationException $e) {
    // Chiave API non valida (401)
} catch (RateLimitException $e) {
    // Troppe richieste (429)
} catch (ApiErrorException $e) {
    // Qualsiasi altro errore API
    echo $e->getHttpStatus();
}
```

In un’applicazione Laravel puoi anche gestire queste eccezioni a livello globale nell’exception handler, oppure usare un middleware per intercettare gli errori di rate limit e implementare nuovi tentativi automatici. Questo assicura che la tua applicazione rimanga resiliente anche quando invia grandi volumi di email.

## Tutti i servizi disponibili

La Facade ti dà accesso a tutta l’API di Emailit:

| Servizio | Utilizzo | Descrizione |
| --- | --- | --- |
| Email | `Emailit::emails()` | Invia, elenca, recupera, annulla e ritenta email |
| Domini | `Emailit::domains()` | Crea, verifica, elenca, gestisci domini di invio |
| Chiavi API | `Emailit::apiKeys()` | Crea, elenca, gestisci chiavi API |
| Liste | `Emailit::audiences()` | Crea, elenca, gestisci liste |
| Iscritti | `Emailit::subscribers()` | Aggiungi, elenca, gestisci iscritti |
| Template | `Emailit::templates()` | Crea, elenca, pubblica template email |
| Soppressioni | `Emailit::suppressions()` | Crea, elenca, gestisci indirizzi soppressi |
| Verifiche email | `Emailit::emailVerifications()` | Verifica indirizzi email |
| Liste di verifica email | `Emailit::emailVerificationLists()` | Verifica email in blocco |
| Webhook | `Emailit::webhooks()` | Crea, elenca, gestisci webhook |
| Contatti | `Emailit::contacts()` | Crea, elenca, gestisci contatti |
| Eventi | `Emailit::events()` | Elenca e recupera eventi |

## Inizia subito

Installa il pacchetto e inizia a inviare in meno di un minuto:

```bash
composer require emailit/emailit-laravel
```

Consulta la documentazione completa del pacchetto su [GitHub](https://github.com/emailit/emailit-laravel), l’[SDK PHP di Emailit](https://github.com/emailit/emailit-php) per il client sottostante, oppure vai al [riferimento API](https://emailit.com/docs/api-reference/endpoints) per i dettagli su ogni endpoint.

---

Source: https://emailit.com/it/blog/invio-email-con-laravel/