# E-Mails mit Laravel versenden

> So versenden Sie E-Mails in Laravel mit dem Laravel-Paket von Emailit: Es fügt sich als nativer Mail-Transport ein und gibt Ihnen über eine Facade vollen Zugriff auf die Emailit-API.

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

Laravel bringt von Haus aus eine hervorragende Mail-Unterstützung mit, aber dahinter brauchen Sie trotzdem einen zuverlässigen Zustelldienst. Das Paket **Emailit Laravel** fügt sich als nativer Transport direkt in das Mail-System von Laravel ein. Ihre bestehenden Mailables, Notifications und `Mail::send()`-Aufrufe funktionieren ohne jede Codeänderung. Zusätzlich erhalten Sie über eine praktische Facade vollen Zugriff auf die Emailit-API.

Der E-Mail-Versand gehört zu den häufigsten Aufgaben in jeder Laravel-Anwendung. Registrierungsbestätigungen, Passwort-Resets, Bestellbestätigungen, Versandupdates und Marketing-Newsletter hängen alle von einer zuverlässigen Zustellung ab. Laravel bietet zwar eine leistungsfähige Abstraktionsschicht für Mails, die tatsächliche Zustellung hängt aber vom konfigurierten Transport ab. Mit einer E-Mail-API wie Emailit erhalten Sie hohe Zustellbarkeit, Zustellverfolgung, Bounce-Management und detaillierte Analysen, ohne SMTP-Server verwalten oder sich um die IP-Reputation sorgen zu müssen.

In dieser Anleitung richten wir Emailit in einer Laravel-Anwendung ein und versenden E-Mails sowohl über das Standard-Mail-System von Laravel als auch über die Emailit-Facade.

## Voraussetzungen

- PHP 8.1 oder höher
- Laravel 10, 11 oder 12
- Ein [Emailit-Konto](https://app.emailit.com/register) mit einem API-Schlüssel

## Installation

Installieren Sie das Paket über Composer:

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

Der Service Provider des Pakets wird automatisch erkannt, eine manuelle Registrierung ist also nicht nötig. Das Paket funktioniert mit Laravel 10, 11 und 12 ohne weitere Einrichtung.

## Konfiguration

Tragen Sie Ihren API-Schlüssel in die `.env` ein:

```
EMAILIT_API_KEY=ihr_api_schluessel
```

Setzen Sie Emailit als Standard-Mailer:

```
MAIL_MAILER=emailit
```

Fügen Sie den Mailer `emailit` zum Array `mailers` in Ihrer `config/mail.php` hinzu:

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

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

Optional können Sie die Konfigurationsdatei veröffentlichen, um die Basis-URL der API anzupassen:

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

Die Konfiguration ist bewusst minimal gehalten. Sobald API-Schlüssel und Standard-Mailer gesetzt sind, leitet Laravel alle ausgehenden E-Mails automatisch über Emailit. SMTP-Hosts, Ports, Verschlüsselung oder Zugangsdaten wie bei einem klassischen Mailserver müssen Sie nicht konfigurieren.

## E-Mails versenden mit Laravel Mail

Nach der Konfiguration funktionieren alle Mail-Funktionen von Laravel sofort. An Ihrem bestehenden Code müssen Sie nichts ändern.

### Verwendung einer Mailable-Klasse

Erstellen Sie eine Mailable-Klasse wie gewohnt:

```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 WelcomeEmail extends Mailable
{
    use Queueable, SerializesModels;

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

    public function envelope(): Envelope
    {
        return new Envelope(
            subject: 'Willkommen in unserer App',
        );
    }

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

Dann versenden Sie sie:

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

Mail::to('benutzer@example.com')->send(new WelcomeEmail($user));
```

E-Mails in der Queue, Markdown-Mailables und Notifications funktionieren genau wie erwartet. Emailit sitzt transparent hinter der Mail-Schicht von Laravel, sodass Sie damit jeden bestehenden Transport wie SMTP, Mailgun oder SES ersetzen können, ohne Ihren Anwendungscode anzufassen. Das macht es einfach, Emailit neben Ihrem aktuellen Anbieter zu testen oder schrittweise zu migrieren.

## Die Emailit-Facade verwenden

Für Funktionen, die über das Mail-System von Laravel hinausgehen, etwa Vorlagen mit Variablen, geplanten Versand oder die Verwaltung von API-Ressourcen, verwenden Sie die Facade `Emailit`. Sie gibt Ihnen direkten Zugriff auf das vollständige [PHP-SDK von Emailit](https://github.com/emailit/emailit-php).

### E-Mail über die API versenden

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

$email = Emailit::emails()->send([
    'from'    => 'hallo@ihredomain.com',
    'to'      => ['benutzer@example.com'],
    'subject' => 'Hallo von Emailit',
    'html'    => '<h1>Willkommen!</h1>',
]);

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

### Mit einer Vorlage versenden

Verweisen Sie auf Vorlagen, die Sie in der Emailit-Weboberfläche erstellt haben, und übergeben Sie dynamische Variablen:

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

$email = Emailit::emails()->send([
    'from'      => 'hallo@ihredomain.com',
    'to'        => 'benutzer@example.com',
    'template'  => 'welcome_email',
    'variables' => [
        'name'    => 'Max Mustermann',
        'company' => 'Musterfirma GmbH',
    ],
]);
```

Serverseitige Vorlagen sind ein starkes Muster für Laravel-Anwendungen. Ihr Design- und Marketing-Team kann Inhalte, Styling und Layout der E-Mails in der Emailit-Weboberfläche ändern, ganz ohne Codeänderungen oder neue Deployments. Der PHP-Code übergibt nur die Daten, das Rendering übernimmt die Vorlage.

### E-Mail planen

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

$email = Emailit::emails()->send([
    'from'         => 'erinnerungen@ihredomain.com',
    'to'           => 'benutzer@example.com',
    'subject'      => 'Termin-Erinnerung',
    'html'         => '<p>Ihr Termin ist morgen um 14:00 Uhr.</p>',
    'scheduled_at' => '2026-04-10T09:00:00Z',
]);
```

Geplante E-Mails werden vollständig von der Emailit-API verwaltet und funktionieren daher unabhängig von Ihrem Queue-System in Laravel. Das ist ideal für Terminerinnerungen, Hinweise zur Verlängerung von Abos und zeitkritische Kampagnen, bei denen der Versand zu einem bestimmten Zeitpunkt garantiert sein soll, selbst wenn Ihr Anwendungsserver gerade ausfällt.

### Versenden mit Anhängen

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

$email = Emailit::emails()->send([
    'from'        => 'rechnungen@ihredomain.com',
    'to'          => 'kunde@example.com',
    'subject'     => 'Ihre Rechnung #12345',
    'html'        => '<p>Bitte finden Sie Ihre Rechnung im Anhang.</p>',
    'attachments' => [
        [
            'filename'     => 'rechnung.pdf',
            'content'      => base64_encode(file_get_contents('rechnung.pdf')),
            'content_type' => 'application/pdf',
        ],
    ],
]);
```

## Ressourcen verwalten

Die Facade stellt jeden Service der Emailit-API bereit, sodass Sie Ihre gesamte E-Mail-Infrastruktur aus Laravel heraus verwalten können.

### Domains

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

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

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

Versanddomains per API zu verwalten, ist nützlich für SaaS-Plattformen, die für jeden Kunden eigene Domains einrichten müssen. Den gesamten Ablauf der Domain-Verifizierung, einschließlich der Prüfung der DNS-Einträge, automatisieren Sie direkt aus Ihrer Laravel-Anwendung.

### Kontakte

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

$contact = Emailit::contacts()->create([
    'email' => 'benutzer@example.com',
    'first_name' => 'Max',
    'last_name' => 'Mustermann',
]);

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

### E-Mail-Verifizierung

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

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

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

Wenn Sie E-Mail-Adressen schon bei der Registrierung oder beim Absenden eines Formulars verifizieren, bleibt Ihre Kontaktliste sauber und Ihre Absenderreputation geschützt. Hohe Bounce-Raten durch ungültige Adressen können dazu führen, dass Ihre E-Mails im Spam landen. Die Verifizierung ist daher bewährte Praxis für jede Laravel-Anwendung, die transaktionale oder Marketing-E-Mails in größerem Umfang versendet.

## Dependency Injection

Wenn Sie lieber keine Facades verwenden möchten, können Sie den Client direkt injizieren:

```php
use Emailit\EmailitClient;

class EmailController extends Controller
{
    public function send(EmailitClient $emailit)
    {
        $email = $emailit->emails()->send([
            'from'    => 'hallo@ihredomain.com',
            'to'      => ['benutzer@example.com'],
            'subject' => 'Hallo',
            'html'    => '<p>Hallo!</p>',
        ]);

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

Der Service Container von Laravel löst die Instanz von `EmailitClient` automatisch mit dem API-Schlüssel aus Ihrer Konfiguration auf. So haben Sie denselben Komfort wie mit der Facade und zugleich die bessere Testbarkeit der Dependency Injection.

## Fehlerbehandlung

Das zugrunde liegende PHP-SDK wirft typisierte Exceptions, sodass Sie gezielt bestimmte Fehlertypen abfangen können:

```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) {
    // Ungültiger API-Schlüssel (401)
} catch (RateLimitException $e) {
    // Zu viele Anfragen (429)
} catch (ApiErrorException $e) {
    // Jeder andere API-Fehler
    echo $e->getHttpStatus();
}
```

In einer Laravel-Anwendung können Sie diese Exceptions auch global in Ihrem Exception Handler behandeln oder per Middleware Rate-Limit-Fehler abfangen und eine automatische Wiederholungslogik umsetzen. So bleibt Ihre Anwendung auch beim Versand großer E-Mail-Mengen robust.

## Alle verfügbaren Services

Die Facade gibt Ihnen Zugriff auf alles in der Emailit-API:

| Service | Verwendung | Beschreibung |
| --- | --- | --- |
| Emails | `Emailit::emails()` | E-Mails senden, auflisten, abrufen, stornieren, erneut senden |
| Domains | `Emailit::domains()` | Versanddomains erstellen, verifizieren, auflisten, verwalten |
| API Keys | `Emailit::apiKeys()` | API-Schlüssel erstellen, auflisten, verwalten |
| Audiences | `Emailit::audiences()` | Kontaktlisten erstellen, auflisten, verwalten |
| Subscribers | `Emailit::subscribers()` | Abonnenten hinzufügen, auflisten, verwalten |
| Templates | `Emailit::templates()` | E-Mail-Vorlagen erstellen, auflisten, veröffentlichen |
| Suppressions | `Emailit::suppressions()` | Gesperrte Adressen erstellen, auflisten, verwalten |
| Email Verifications | `Emailit::emailVerifications()` | E-Mail-Adressen verifizieren |
| Email Verification Lists | `Emailit::emailVerificationLists()` | Massen-E-Mail-Verifizierung |
| Webhooks | `Emailit::webhooks()` | Webhooks erstellen, auflisten, verwalten |
| Contacts | `Emailit::contacts()` | Kontakte erstellen, auflisten, verwalten |
| Events | `Emailit::events()` | Events auflisten und abrufen |

## Loslegen

Installieren Sie das Paket und beginnen Sie in unter einer Minute mit dem Versenden:

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

Die vollständige Dokumentation des Pakets finden Sie auf [GitHub](https://github.com/emailit/emailit-laravel), den zugrunde liegenden Client im [PHP-SDK von Emailit](https://github.com/emailit/emailit-php) und Details zu jedem Endpunkt in der [API-Referenz](https://emailit.com/docs/api-reference/endpoints).

---

Source: https://emailit.com/de/blog/e-mails-versenden-mit-laravel/