E-Mails mit PHP versenden

Das Versenden von E-Mails aus PHP bedeutete traditionell den Kampf mit mail(), die Konfiguration von SMTP-Servern oder das Einbinden schwerer Abhängigkeiten. Das Emailit PHP SDK bietet Ihnen eine saubere, moderne Alternative. Sie können Transaktions-E-Mails versenden, Domains verwalten, Adressen verifizieren und Webhooks handhaben – 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 Online-Shop oder ein Content-Management-System entwickeln – zuverlässige E-Mail-Zustellung ist unverzichtbar für Benutzer-Onboarding, Passwort-Resets, Bestellbestätigungen und Marketing-Kampagnen. Anstatt sich auf PHPs eingebaute mail()-Funktion zu verlassen, die nur begrenzte Kontrolle und keine Zustellungsgarantien bietet, gewährleistet die Nutzung einer dedizierten E-Mail-API, dass Ihre Nachrichten tatsächlich im Posteingang ankommen.

In diesem Leitfaden führen wir Sie durch die Installation des SDKs und zeigen, wie Sie es zum Versenden von E-Mails aus jeder PHP-Anwendung nutzen.

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 Emailit PHP SDK ist als Composer-Paket verfügbar und lässt sich nahtlos in jedes PHP-Projekt integrieren, das Composer für die Abhängigkeitsverwaltung nutzt. Manuelle Datei-Includes oder benutzerdefinierte Autoloader sind nicht erforderlich.

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 im Emailit-Dashboard unter API-Schlüssel.

Einfache E-Mail versenden

Das Versenden einer E-Mail erfordert nur einen einzigen 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 Ressourcen-Objekte mit direktem Eigenschaftszugriff zurück, sodass Sie immer genau wissen, womit Sie arbeiten.

Im Vergleich zur Nutzung von PHPs nativer mail()-Funktion bietet das Versenden von E-Mails über eine API Zustellungsverfolgung, Bounce-Behandlung und detaillierte Statusinformationen für jede Nachricht. Sie müssen sich keine Gedanken über die Konfiguration von Sendmail oder Postfix auf Ihrem Server machen und erhalten zuverlässige Zustellung bei allen großen E-Mail-Anbietern wie Gmail, Outlook und Yahoo.

Mit Vorlage versenden

Wenn Sie eine Vorlage im Emailit-Dashboard erstellt haben, können Sie diese über den Slug referenzieren 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',
    ],
]);

Vorlagen halten Ihre E-Mail-Inhalte aus der Codebasis heraus und ermöglichen es Nicht-Entwicklern, Texte ohne Deployment zu aktualisieren. Dies ist besonders nützlich für Transaktions-E-Mails wie Willkommensnachrichten, Passwort-Reset-Links, Rechnungsbelege und Versandbenachrichtigungen, bei denen sich Design und Formulierung häufiger ändern als der Code, der sie auslöst.

Mit Anhängen versenden

Fügen Sie Dateien hinzu, 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. Dies wird häufig verwendet, um Rechnungen, Berichte oder generierte Dokumente direkt aus Ihrer PHP-Anwendung zu versenden, ohne einen separaten Download-Link zu benötigen.

E-Mail für später planen

Übergeben Sie einen scheduled_at-Zeitstempel, um zu einem zukünftigen Datum 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');

Die Terminplanung ist nützlich für zeitkritische Kommunikation wie Terminerinnerungen, Abonnement-Verlängerungshinweise und Drip-Kampagnen, bei denen der Sendezeitpunkt genauso wichtig ist wie der Inhalt selbst.

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";
}

Fehlgeschlagene E-Mail erneut versuchen:

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

Die vollständige Einsicht in Ihre gesendeten E-Mails, deren Zustellungsstatus und die Möglichkeit, Fehlschläge zu wiederholen, bietet Ihnen eine Kontrollebene, die PHPs mail()-Funktion einfach nicht bieten kann. Dies ist entscheidend für Anwendungen, bei denen jede E-Mail zählt, wie Transaktionsbelege, Kontoverifizierungslinks und Zwei-Faktor-Authentifizierungscodes.

E-Mail-Adressen vor dem Versand verifizieren

Reduzieren Sie Bounces durch vorherige Adressverifizierung:

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

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

E-Mail-Verifizierung ist eine bewährte Praxis zum Schutz Ihrer Absender-Reputation. Das Versenden an ungültige oder Wegwerf-E-Mail-Adressen erhöht Ihre Bounce-Rate, was Spam-Filter 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 handhaben

Das SDK enthält typisierte Event-Klassen und Signaturverifizierung für Webhooks. Dies ermöglicht es Ihnen, in Echtzeit auf Zustellungsereignisse zu reagieren:

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}"),
};

Webhooks ermöglichen es Ihrer PHP-Anwendung, sofort zu reagieren, wenn eine E-Mail zugestellt, zurückgewiesen, geöffnet oder geklickt wird. Dies ist unverzichtbar für den Aufbau ereignisgesteuerter Workflows wie die Aktualisierung eines CRM bei Nachrichtenzustellung, die Benachrichtigung Ihres Support-Teams bei Bounces oder die Verfolgung von Engagement-Metriken für Ihre E-Mail-Kampagnen.

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();
}

Ordnungsgemäße Fehlerbehandlung gewährleistet, dass Ihre Anwendung elegant degradiert, wenn etwas schiefgeht. Rate-Limit-Exceptions können beispielsweise mit einer Wiederholungsstrategie behandelt werden, 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 vollständige Emailit-API, nicht nur auf das Versenden. Sie können Domains, API-Schlüssel, Zielgruppen, Abonnenten, Vorlagen, Unterdrückungen, 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();

Dies macht das Emailit PHP SDK zu einem vollständigen E-Mail-Infrastruktur-Toolkit. Anstatt separate Bibliotheken oder Services für Domain-Management, Kontaktlisten und E-Mail-Versand zu verwenden, können Sie alles über einen einzigen, konsistenten PHP-Client handhaben.

Loslegen

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

composer require emailit/emailit-php

Schauen Sie sich die vollständige SDK-Dokumentation auf GitHub an oder besuchen Sie die API-Referenz für Details zu jedem Endpoint.