E-Mails mit PHP versenden

E-Mails aus PHP zu versenden, bedeutete lange, sich mit mail() herumzuschlagen, SMTP-Server zu konfigurieren oder schwere Abhängigkeiten einzubinden. Das PHP-SDK von Emailit ist eine saubere, moderne Alternative: Sie versenden transaktionale E-Mails, verwalten Domains, verifizieren Adressen und verarbeiten Webhooks, alles über einen einfachen API-Client.

PHP bleibt eine der am weitesten verbreiteten Sprachen für die Webentwicklung, und das Versenden von E-Mails ist eine Grundanforderung für nahezu jede PHP-Anwendung. Ob Sie ein SaaS-Produkt, einen Onlineshop oder ein Content-Management-System entwickeln: Zuverlässige Zustellung ist unverzichtbar für das Onboarding von Nutzern, Passwort-Resets, Bestellbestätigungen und Marketing-Kampagnen. Statt sich auf die eingebaute PHP-Funktion mail() zu verlassen, die wenig Kontrolle und keinerlei Zustellgarantie bietet, sorgt eine spezialisierte E-Mail-API dafür, dass Ihre Nachrichten tatsächlich im Posteingang ankommen.

In dieser Anleitung installieren wir das SDK und zeigen, wie Sie damit E-Mails aus jeder PHP-Anwendung versenden.

Voraussetzungen

• PHP 8.1 oder höher
• Ein Emailit-Konto mit einem API-Schlüssel
• Composer

Installation

Installieren Sie das SDK über Composer:

composer require emailit/emailit-php

Das PHP-SDK von Emailit ist als Composer-Paket verfügbar und lässt sich nahtlos in jedes PHP-Projekt einbinden, das Abhängigkeiten mit Composer verwaltet. Manuelle Includes oder eigene Autoloader sind nicht nötig.

Client initialisieren

Erstellen Sie eine Client-Instanz mit Ihrem API-Schlüssel:

require 'vendor/autoload.php';

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

Ihren API-Schlüssel finden Sie in der Emailit-Weboberfläche unter API Keys.

Einfache E-Mail versenden

Für den Versand einer E-Mail genügt ein einziger Methodenaufruf:

$email = $emailit->emails()->send([
    'from'    => 'hello@ihredomain.com',
    'to'      => ['user@example.com'],
    'subject' => 'Hallo von Emailit',
    'html'    => '<h1>Willkommen!</h1><p>Vielen Dank für Ihre Anmeldung.</p>',
]);

echo $email->id;     // em_abc123...
echo $email->status; // pending

Alle Service-Methoden geben typisierte Ressourcenobjekte mit direktem Zugriff auf ihre Eigenschaften zurück, sodass Sie immer genau wissen, womit Sie arbeiten.

Anders als die native PHP-Funktion mail() bietet Ihnen der Versand über eine API Zustellverfolgung, Bounce-Verarbeitung und detaillierte Statusinformationen zu jeder Nachricht. Sie müssen weder Sendmail noch Postfix auf Ihrem Server konfigurieren und erhalten eine zuverlässige Zustellung bei allen großen Anbietern wie Gmail, Outlook und Yahoo.

Mit Vorlage versenden

Wenn Sie in der Emailit-Weboberfläche eine Vorlage erstellt haben, können Sie per Slug auf sie verweisen und Variablen übergeben:

$email = $emailit->emails()->send([
    'from'      => 'hello@ihredomain.com',
    'to'        => 'user@example.com',
    'template'  => 'welcome_email',
    'variables' => [
        'name'    => 'Max Mustermann',
        'company' => 'Musterfirma GmbH',
    ],
]);

Mit Vorlagen bleiben Ihre E-Mail-Inhalte aus der Codebasis heraus, und auch Nicht-Entwickler können Texte ohne Deployment ändern. Das ist besonders praktisch bei transaktionalen E-Mails wie Willkommensnachrichten, Links zum Zurücksetzen des Passworts, Rechnungen und Versandbenachrichtigungen, bei denen sich Design und Wortlaut häufiger ändern als der Code, der sie auslöst.

Mit Anhängen versenden

Hängen Sie Dateien an, indem Sie Base64-kodierten Inhalt übergeben:

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

Sie können PDFs, Bilder, Tabellen oder jeden anderen Dateityp anhängen. Häufig werden so Rechnungen, Berichte oder generierte Dokumente direkt aus der PHP-Anwendung verschickt, ganz ohne separaten Download-Link.

E-Mail für später planen

Übergeben Sie einen Zeitstempel in scheduled_at, um zu einem späteren Zeitpunkt zu versenden:

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

echo $email->status;       // scheduled
echo $email->scheduled_at; // 2026-04-10T09:00:00Z

Geplante E-Mails können vor dem Versand storniert werden:

$emailit->emails()->cancel('em_abc123');

Geplanter Versand ist nützlich für zeitkritische Nachrichten wie Terminerinnerungen, Hinweise zur Verlängerung von Abos und Drip-Kampagnen, bei denen der Versandzeitpunkt genauso wichtig ist wie der Inhalt.

Gesendete E-Mails auflisten und verwalten

Rufen Sie eine paginierte Liste Ihrer E-Mails ab:

$emails = $emailit->emails()->list(['page' => 1, 'limit' => 10]);

foreach ($emails as $email) {
    echo $email->id . ' - ' . $email->status . "\n";
}

Eine fehlgeschlagene E-Mail erneut senden:

$emailit->emails()->retry('em_abc123');

Der volle Einblick in Ihre gesendeten E-Mails und deren Zustellstatus sowie die Möglichkeit, Fehlschläge erneut zu senden, geben Ihnen ein Maß an Kontrolle, das die PHP-Funktion mail() schlicht nicht bieten kann. Das ist entscheidend für Anwendungen, bei denen jede E-Mail zählt, etwa Kaufbestätigungen, Links zur Kontoverifizierung und Codes für die Zwei-Faktor-Authentifizierung.

E-Mail-Adressen vor dem Versand verifizieren

Reduzieren Sie Bounces, indem Sie Adressen vorab verifizieren:

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

echo $result->status; // valid
echo $result->score;  // 0.95
echo $result->risk;   // low

Die E-Mail-Verifizierung ist bewährte Praxis, um Ihre Absenderreputation zu schützen. Der Versand an ungültige oder Wegwerf-Adressen erhöht Ihre Bounce-Rate, was Spamfilter auslösen und die Zustellbarkeit Ihrer gesamten Domain beeinträchtigen kann. Durch die Verifizierung von Adressen vor dem Versand halten Sie Ihre Bounce-Raten niedrig und Ihre Reputation intakt.

Webhook-Events verarbeiten

Das SDK enthält typisierte Event-Klassen und eine Signaturprüfung für Webhooks. So reagieren Sie in Echtzeit auf Zustell-Events:

use Emailit\WebhookSignature;
use Emailit\Events\EmailDelivered;
use Emailit\Events\EmailBounced;

$event = WebhookSignature::verify(
    file_get_contents('php://input'),
    $_SERVER['HTTP_X_EMAILIT_SIGNATURE'],
    $_SERVER['HTTP_X_EMAILIT_TIMESTAMP'],
    'ihr_webhook_signatur_geheimnis'
);

match (true) {
    $event instanceof EmailDelivered => handleDelivered($event),
    $event instanceof EmailBounced   => handleBounce($event),
    default                          => log("Unbehandelt: {$event->type}"),
};

Mit Webhooks reagiert Ihre PHP-Anwendung sofort, wenn eine E-Mail zugestellt, gebounct, geöffnet oder angeklickt wird. Das ist unverzichtbar für eventgesteuerte Workflows, etwa um bei einer Zustellung Ihr CRM zu aktualisieren, Ihr Support-Team bei Bounces zu benachrichtigen oder Engagement-Kennzahlen Ihrer E-Mail-Kampagnen zu verfolgen.

Fehlerbehandlung

Das SDK wirft typisierte Exceptions, sodass Sie jeden Fehlerfall präzise behandeln können:

use Emailit\Exceptions\AuthenticationException;
use Emailit\Exceptions\RateLimitException;
use Emailit\Exceptions\UnprocessableEntityException;
use Emailit\Exceptions\ApiErrorException;

try {
    $emailit->emails()->send([...]);
} catch (AuthenticationException $e) {
    // Ungültiger API-Schlüssel (401)
} catch (RateLimitException $e) {
    // Zu viele Anfragen (429)
} catch (UnprocessableEntityException $e) {
    // Validierung fehlgeschlagen (422)
} catch (ApiErrorException $e) {
    // Jeder andere API-Fehler
    echo $e->getHttpStatus();
}

Mit sauberer Fehlerbehandlung reagiert Ihre Anwendung kontrolliert, wenn etwas schiefgeht. Rate-Limit-Exceptions lassen sich zum Beispiel mit einer Wiederholungsstrategie abfangen, während Authentifizierungsfehler eine Warnung auslösen sollten, damit Sie Ihren API-Schlüssel rotieren können.

Über E-Mails hinaus

Das SDK gibt Ihnen Zugriff auf die komplette Emailit-API, nicht nur auf den Versand. Sie können Domains, API-Schlüssel, Kontaktlisten, Abonnenten, Vorlagen, Sperrungen, Kontakte und Events verwalten, alles aus PHP heraus:

$domain = $emailit->domains()->create(['name' => 'example.com']);
$contact = $emailit->contacts()->create(['email' => 'user@example.com']);
$templates = $emailit->templates()->list();

Damit ist das PHP-SDK von Emailit ein vollständiges Toolkit für Ihre E-Mail-Infrastruktur. Statt separater Bibliotheken oder Dienste für Domainverwaltung, Kontaktlisten und Versand erledigen Sie alles über einen einzigen, konsistenten PHP-Client.

Loslegen

Installieren Sie das SDK und versenden Sie Ihre erste E-Mail in unter einer Minute:

composer require emailit/emailit-php

Die vollständige Dokumentation des SDK finden Sie auf GitHub, Details zu jedem Endpunkt in der API-Referenz.