E-Mails in PHP senden mit SMTP oder API: PHPMailer, Symfony Mailer und die mail()-Funktion

On Juli 30, 2025
26min read
Viktoriia Ivanenko Technical Content Writer @ Mailtrap
Ivan Djuric, an author at Mailtrap
Ivan Djuric Technical Content Writer @Mailtrap
Table of Contents

Wenn Sie sich fragen, wie man E-Mails in PHP sendet, sind Sie wahrscheinlich nicht der Einzige, denn laut W3Tech-Berichten nutzen selbst im Jahr 2024 noch 76,4 % aller Websites PHP.

Glücklicherweise sind Sie hier genau richtig.

Ich recherchiere dieses Thema schon seit einer Weile, und in diesem Artikel zeige ich Ihnen die beliebtesten Optionen zum Senden von E-Mails aus PHP.

Die Prozesse und Codeblöcke, die ich Ihnen in diesem Artikel zeige, sind mit PHP Version 7 und höher kompatibel.

Sind Sie bereit, Ihre E-Mails zuzustellen?
Mailtrap kostenlos testen

Wie man E-Mails mit PHPMailer sendet

PHPMailer ist eine der beliebtesten, wenn nicht die beliebteste E-Mail-Versandbibliothek für PHP. Sie ist mit den meisten PHP-Frameworks (z. B. Laravel, Symfony usw.) kompatibel und bietet leistungsstarke Funktionen und verschiedene Merkmale, wie z. B.:

  • SMTP-Authentifizierung
  • Sichere/MIME-Verschlüsselung
  • Unterstützung der Protokolle TLS und SSL
  • Plain-Text- und HTML-Inhalt
  • Mehrteilige Vorlagen/komplexes HTML
  • Mehrere Formate, String- und Binäranhänge
  • Unterstützung für eingebettete Bilder
  • Schutz vor Header-Injection-Angriffen
  • Funktionalität zur automatischen E-Mail-Validierung

Beachten Sie, dass PHPMailer keinen integrierten Mailversand hat. Es kann E-Mails mit der mail()-Funktion von PHP senden, aber wegen potenzieller Spam-bezogener Probleme und der Komplexität des gesamten Prozesses empfehle ich es nicht. Wenn Sie jedoch mehr darüber lesen möchten, lesen Sie unbedingt unseren dedizierten PHPMailer-Artikel.

Idealerweise wird PHPMailer jedoch mit einem externen SMTP-Server verwendet, mit dem es zuverlässig und sicher ist, was es zu einer perfekten Wahl als E-Mail-Versandfunktion für Ihre PHP-Anwendung macht.

Ich werde nun beschreiben, wie Sie PHPMailer für jeden SMTP-Anbieter (z. B. Mailtrap, SendGrid, Postmark usw.) konfigurieren, und später zeige ich Ihnen, wie Sie es mit Mailtrap SMTP verwenden, damit Sie sehen können, wie es in Aktion funktioniert.

Installieren Sie zuerst die Bibliothek über Composer, einen Abhängigkeitsmanager für PHP, der von den PHPMailer-Erstellern auf GitHub empfohlen wird. Sie können auch der manuellen Anleitung zur Installation folgen.

Sobald Sie Composer installiert haben, fügen Sie entweder diese Zeile zu Ihrer Datei composer.json hinzu:

"phpmailer/phpmailer": "^6.9"

oder führen Sie den folgenden Befehl aus:

composer require phpmailer/phpmailer

Alternativ können Sie PHPMailer manuell hinzufügen, wenn Sie Composer nicht installieren möchten, was in einer Testumgebung praktisch sein kann. Laden Sie dazu die Dateien mit dem PHPMailer-Quellcode herunter, kopieren Sie den Inhalt des PHPMailer-Ordners in eines der in Ihrer PHP-Konfiguration angegebenen include_path-Verzeichnisse und laden Sie jede Klassendatei manuell:

<?php
use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\Exception;
require 'path/to/PHPMailer/src/Exception.php';
require 'path/to/PHPMailer/src/PHPMailer.php';
require 'path/to/PHPMailer/src/SMTP.php';

Nun müssen Sie nur noch die von Ihrem SMTP-Dienstanbieter bereitgestellten Zugangsdaten hinzufügen (z. B. Benutzername, Passwort, SMTP-Port usw.). Sie sollten etwa so aussehen:

$mail->isSMTP();
$mail->Host = 'live.smtp.mailtrap.io';
$mail->SMTPAuth = true;
$mail->Username = 'api';
$mail->Password = '1a2b3c4d5e6f7g';
$mail->SMTPSecure = 'tls';
$mail->Port = 587;

Und so sieht es zusammen mit dem Code aus, den Sie zum Senden von E-Mails verwenden können:

<?php

// Start with PHPMailer class
use PHPMailer\PHPMailer\PHPMailer;
require_once './vendor/autoload.php';

// create a new object
$mail = new PHPMailer();

// configure an SMTP
$mail->isSMTP();
$mail->Host = 'live.smtp.mailtrap.io';
$mail->SMTPAuth = true;
$mail->Username = 'api';
$mail->Password = '1a2b3c4d5e6f7g';
$mail->SMTPSecure = PHPMailer::ENCRYPTION_STARTTLS;
$mail->Port = 587;

$mail->setFrom('bestaetigung@registrierte-domain', 'Ihr Hotel');
$mail->addAddress('empfaenger@gmail.com', 'Ich');
$mail->Subject = 'Danke, dass Sie sich für Unser Hotel entschieden haben!';

// Set HTML 
$mail->isHTML(TRUE);
$mail->Body = '<html>Hallo, wir freuen uns,<br>Ihre Buchung zu bestätigen.</br> Bitte prüfen Sie das Dokument im Anhang.</html>';
$mail->AltBody = 'Hallo, wir freuen uns, Ihre Buchung zu bestätigen. Bitte prüfen Sie das Dokument im Anhang.;
// Anhang hinzufügen 

// Fügen Sie einfach den '/pfad/zur/datei.pdf' hinzu
$attachmentPath = './bestaetigungen/ihrebuchung.pdf';
if (file_exists($attachmentPath)) {
    $mail->addAttachment($attachmentPath, 'ihrebuchung.pdf');
}

// Die Nachricht senden
if(!$mail->send()){
    echo 'Nachricht konnte nicht gesendet werden.';
    echo 'Mailer Error: ' . $mail->ErrorInfo;
} else {
    echo 'Nachricht wurde gesendet.';
}

Wie man E-Mails mit Symfony Mailer sendet

Wir schreiben das Jahr 2025, was bedeutet, dass Pear::Mail und Swift Mailer mittlerweile ziemlich veraltet sind, sodass uns Symfony als unsere nächste naheliegende Wahl für das Senden von E-Mails in PHP bleibt. Es ist ein super flexibles Framework, und dank seiner neuen Mailer- und Mime-Komponenten, die im Symfony 4.3 Release eingeführt wurden, bietet es folgende Funktionen:

  • CSS-Inlining
  • Twig-Vorlagenintegration
  • Dateianhänge
  • Signieren und Verschlüsseln von Nachrichten
  • Direkte Integration mit den beliebtesten E-Mail-Versandanbietern
  • Asynchroner E-Mail-Versand mit Symfony Messenger

Wie PHPMailer ermöglicht Symfony das Senden von E-Mails mit und ohne externen SMTP-Dienst durch die Verwendung von Sendmail oder anderen lokalen Transporten. Obwohl ich kein großer Fan des Sendmail-Programms bin, da es einer strengeren Prüfung durch Spamfilter unterliegt und viel mehr Wartung erfordert, zeige ich Ihnen hier, wie Sie es tun können:

Installieren Sie zuerst die Mime- und Mailer-Komponenten wie folgt:

composer require symfony/mailer

Führen Sie dann das folgende Skript aus:

<?php

use Symfony\Component\Mailer\Mailer;
use Symfony\Component\Mailer\Transport\SendmailTransport;
use Symfony\Component\Mime\Email;

require_once './vendor/autoload.php';

// Create the Sendmail transport
$transport = new SendmailTransport();

// Create the Mailer using your created Transport
$mailer = new Mailer($transport);

// Create a new email
$email = (new Email())
    ->from('hallo@beispiel.com')
    ->to('sie@beispiel.com')
    ->subject('Sendmail mit Symfony verwenden!')
    ->text('E-Mails mit Sendmail senden ist einfach!')
    ->html('<p>Siehe Twig-Integration für bessere HTML-Integration!</p>');

// Senden Sie die E-Mail
$mailer->send($email);

Wenn Sie Ihre E-Mails hingegen sicher und mit einer höheren Zustellrate senden möchten, finden Sie hier ein Snippet, das Sie mit Symfony und einem externen SMTP verwenden können:

<?php

use Symfony\Component\Mailer\Mailer; 
use Symfony\Component\Mailer\Transport\Smtp\SmtpTransport; 
use Symfony\Component\Mime\Email;

require_once './vendor/autoload.php';


$transport = (new Symfony\Component\Mailer\Transport\Smtp\EsmtpTransport
('smtp.server.com', 587))
                ->setUsername('benutzername')
                ->setPassword('password');

$mailer = new Mailer($transport); 

$email = (new Email())
            ->from('hallo@registriert.com')
            ->to('sie@beispiel.com')
            ->subject('Zeit für Symfony Mailer!')
            ->text('E-Mails senden macht wieder Spaß!')
            ->html('<p>Siehe Twig-Integration für bessere HTML-Integration!</p>');

$mailer->send($email);

Weitere Informationen zum Senden von E-Mails mit Symfony Mailer finden Sie in unserer detaillierten Anleitung, die den gesamten Prozess erklärt, sowie in der offiziellen Dokumentation für die aktuelle Version.

PHP mail()-Funktion

Die PHP mail()-Funktion ist eine integrierte Funktion zum Senden von E-Mails aus PHP, weist jedoch einige Einschränkungen und Nachteile auf, die sie weniger beliebt und gewissermaßen zu einem Elefanten im Raum machen. 🐘

Namentlich ist sie anfällig für Zustellbarkeitsprobleme, da sie von der Konfiguration des lokalen Mailservers abhängt (z. B. sendet sie E-Mails von Ihrem Webserver), was dazu führen kann, dass E-Mails als Spam markiert oder von E-Mail-Dienstanbietern abgelehnt werden. Sie verfügt nicht über viele erweiterte Funktionen wie E-Mail-Tracking und, was am wichtigsten ist, sie kann anfällig für E-Mail-Injection-Angriffe sein.

Daher sehen Sie, warum ich die mail()-Funktion nicht empfehle. Dennoch zeige ich Ihnen zu Erklärungszwecken, wie sie funktioniert.

Die Syntax für die PHP mail-Funktion ist recht einfach:

<?php
mail($to,$subject,$message,[$headers],[$parameters]);
?>

Sie verwendet die folgenden obligatorischen Parameter:

  • $to = E-Mail Ihres Nachrichtenempfängers. Das E-Mail-Adressformat kann benutzer@beispiel.com oder Benutzer <benutzer@beispiel.com> sein. Im Allgemeinen muss es RFC 2822 entsprechen. Dies ist obligatorisch.
  • <strong>$subject</strong>= Betreff Ihrer Nachricht.
  • $message = Der Textkörper Ihrer Nachricht. Zeilen sollten mit einem Wagenrücklauf Zeilenvorschub, CRLF, (\r\n) getrennt werden. Jede Zeile sollte 70 Zeichen nicht überschreiten.
  • $headers = Der obligatorische Header ist der From-Header: Er muss angegeben werden, andernfalls erhalten Sie eine Fehlermeldung wie Warning: mail(): “sendmail_from” nicht in php.ini gesetzt oder benutzerdefinierter From:-Header fehlt.

Die zusätzlichen Header geben andere Empfänger oder Kopien Ihrer Nachricht wie CC oder BCC an. Sie können ein Array sein, bei dem der Schlüssel ein Headername und der Wert ein Headerwert ist. Oder sie können ein String sein. In diesem Fall sollten Header mit einem CRLF (\r\n) getrennt werden.

  • $parameters = Zur Angabe der zusätzlichen Parameter, die in der sendmail_path-Konfigurationseinstellung definiert sind.

So können Sie eine Plain-Text-E-Mail mit zusätzlichen Headern senden:

<?php
$to = "jemand@beispiel.com";
$subject = "Mein Betreff";
$txt = "Hallo Welt!";
$headers = "From: webmaster@beispiel.com" . "\r\n" .
"CC: jemandanderes@beispiel.com";

mail($to,$subject,$txt,$headers);
?>

Sie müssen auch zum PHP-Dateiinstallationsordner gehen und die SMTP-Einstellungen in der Datei php.ini konfigurieren. Dies funktioniert jedoch nur für Localhost oder XAMPP-ähnliche Lösungen, da, wie bereits erwähnt, die PHP mail()-Funktion keine SMTP-Authentifizierung unterstützt und das Senden von Nachrichten über externe Server nicht erlaubt.

Wenn Sie mir nun nicht glauben, dass das Senden von HTML-E-Mails mit der mail-Funktion knifflig ist, sehen Sie hier, wie der HTML-Nachrichtenteil normalerweise aussieht:

// Nachricht
$message = '
<html>
<head>
  <title>Erinnerung an Überprüfungsanfrage</title>
</head>
<body>
  <p>Hier sind die Fälle, die im Dezember Ihre Überprüfung erfordern:</p>
  <table>
    <tr>
      <th>Falltitel</th><th>Kategorie</th><th>Status</th><th>Fälligkeitsdatum</th>
    </tr>
    <tr>
      <td>Fall 1</td><td>Entwicklung</td><td>ausstehend</td><td>20. Dez.</td>
    </tr>
    <tr>
      <td>Fall 2</td><td>DevOps</td><td>ausstehend</td><td>21. Dez.</td>
    </tr>
  </table>
</body>
</html>
';

Um HTML-Mail zu senden, müssen Sie auch den Content-Type-Header setzen:

$headers = "MIME-Version: 1.0" . "\r\n";
$headers .= "Content-type:text/html;charset=UTF-8" . "\r\n";

or 

$headers['MIME-Version'] = 'MIME-Version: 1.0';
$headers['Content-type'] = text/html; charset=iso-8859-1';

Und wenn Sie Ihre Nachricht an mehrere Empfänger senden möchten, geben Sie deren E-Mail-Adressen im Parameter $to = an und trennen Sie sie mit (einem) Komma(s).

Vergessen Sie nicht, dass Sie beim Senden von E-Mails mit mail() auf gravierende E-Mail-Zustellbarkeitsprobleme stoßen können. ❌ Die versendeten Nachrichten profitieren nicht von der SPF- und DKIM-Einrichtung auf Ihrer Domain. Daher werden die Nachrichten wahrscheinlich vom empfangenden MTA (Mail Transfer Agent) als Spam behandelt. Somit ist die Gesamt-Zustellbarkeit von E-Mail-Nachrichten, die über die PHP mail()-Funktion gesendet werden, nicht garantiert. Schließlich erhalten Sie keine Bounce-Nachrichten, wenn eine Zustellung fehlschlägt.

E-Mails über SMTP senden

Nun zeige ich Ihnen, wie Sie PHPMailer mit Mailtrap Email API/SMTP SMTP verwenden, da es höhere Zustellraten als andere Optionen bietet und super einfach zu konfigurieren ist.

Das Erste, was Sie tun müssen, ist ein Konto zu registrieren und Ihre E-Mail-Sendedomäne zu verifizieren, wie im Video unten beschrieben:

Finden Sie dann die von Mailtrap bereitgestellten SMTP-Zugangsdaten im Abschnitt „Sending Domains“ unter dem Tab „SMTP/API Settings“.

Ein Screenshot, der die Mailtrap Email API/SMTP SMTP/API-Einstellungen und den Transaktionalen Stream zeigt.

Wichtig: Wählen Sie vorerst den Transaktionalen Stream; auf den Massenversand-Stream gehe ich später im Artikel ein.

Nun müssen Sie nur noch das folgende Skript verwenden, um eine Plain-Text-E-Mail zu senden und Ihre Zugangsdaten darin einzufügen:

<?php
use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\Exception;

require 'vendor/autoload.php'; // Passen Sie den Pfad entsprechend Ihrer Installationsmethode an
$mail = new PHPMailer(true); // Ausnahmen aktivieren

// SMTP-Konfiguration
$mail->isSMTP();
$mail->Host = 'live.smtp.mailtrap.io'; // Ihr SMTP-Server
$mail->SMTPAuth = true;
$mail->Username = 'ihr_benutzername'; // Ihr Mailtrap-Benutzername
$mail->Password = 'ihr_passwort'; // Ihr Mailtrap-Passwort
$mail->SMTPSecure = 'tls';
$mail->Port = 587;

// Absender- und Empfängereinstellungen
$mail->setFrom('von@beispiel.com', 'Absender Name');
$mail->addAddress('empfaenger@beispiel.com', 'Empfänger Name');

// Plain-Text-E-Mail senden
$mail->isHTML(false); // E-Mail-Format auf Plain-Text setzen
$mail->Subject = 'Ihr Betreff hier';
$mail->Body    = 'Dies ist der Plain-Text-Nachrichtentext';

// Die E-Mail senden
if(!$mail->send()){
    echo 'Nachricht konnte nicht gesendet werden. Mailer Error: ' . $mail->ErrorInfo;
} else {
    echo 'Nachricht wurde gesendet';
}

Vergessen Sie nicht, sicherzustellen, dass die Methode isHTML auf false gesetzt ist, wenn Sie Plain-Text-E-Mails senden möchten.

HTML-E-Mail senden

Vertiefen Sie sich in die Anpassung von HTML-E-Mails in PHP, indem Sie unseren dedizierten Artikel lesen.

Um eine einfache HTML-Nachricht mit PHPMailer zu senden, müssen wir nur sicherstellen, dass die Eigenschaft isHTML auf (true) gesetzt ist, und wir können sie wie folgt senden:

<?php
use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\Exception;

require 'path/to/composer/vendor/autoload.php'; // Stellen Sie sicher, dass der Pfad korrekt ist

$mail = new PHPMailer(true); // Übergabe von `true` aktiviert Ausnahmen

try {
  $mail->isSMTP();
  $mail->Host = 'live.smtp.mailtrap.io';
  $mail->SMTPAuth = true;
  $mail->Username = 'von Mailtrap generierten einfügen'; // Ihr Mailtrap-Benutzername
  $mail->Password = 'von Mailtrap generierten einfügen'; // Ihr Mailtrap-Passwort
  $mail->SMTPSecure = 'tls';
  $mail->Port = 587;
  
  $mail->setFrom('von@beispiel.com', 'Vorname Nachname');
  $mail->addReplyTo('anwen@beispiel.com', 'Max Mustermann'); //
  $mail->addAddress('empfaenger@beispiel.com', 'Empfänger Name'); // Einen Empfänger hinzufügen
  
  $mail->isHTML(true); // E-Mail-Format auf HTML setzen
  $mail->Subject = "PHPMailer SMTP-Test";
  $mail->Body = "<h1>HTML-E-Mail über SMTP in PHP senden</h1><p>Dies ist eine Test-E-Mail, die ich über einen SMTP-Mailserver mit PHPMailer sende.</p>"; // Beispiel HTML-Body
    $mail->AltBody = 'Dies ist die Plain-Text-Version des E-Mail-Inhalts';

    if(!$mail->send()){
        echo 'Nachricht konnte nicht gesendet werden.';
        echo 'Mailer Error: ' . $mail->ErrorInfo;
    } else {
        echo 'Nachricht wurde gesendet';
    }
} catch (Exception $e) {
    echo "Nachricht konnte nicht gesendet werden
. Mailer Error: {$mail->ErrorInfo}";
}
E-Mails kostenlos mit Mailtrap senden

E-Mail an mehrere Empfänger senden

Um E-Mails an mehrere Empfänger zu senden, müssen Sie lediglich die Methode addAddress() für jeden Empfänger aufrufen.

Hier ist ein Code-Snippet zum Senden einer HTML- und Plain-Text-E-Mail an mehrere Empfänger:

<?php
use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\Exception;

require 'path/to/composer/vendor/autoload.php';

$mail = new PHPMailer(true); // Ausnahmen aktivieren
$mail->isSMTP();
$mail->Host = 'live.smtp.mailtrap.io';
$mail->SMTPAuth = true;
$mail->Username = '1a2b3c4d5e6f7g'; // Ihr Mailtrap-Benutzername
$mail->Password = '1a2b3c4d5e6f7g'; // Ihr Mailtrap-Passwort
$mail->SMTPSecure = 'tls';
$mail->Port = 587;
$mail->SMTPKeepAlive = true; // SMTP-Verbindung nach jeder gesendeten E-Mail offen halten

$mail->setFrom('liste@beispiel.com', 'Listen-Manager');
$mail->Subject = "Neue Mailtrap Mailingliste";

$users = [
  ['email' => 'max@beispiel.com', 'name' => 'Max'],
  ['email' => 'bob@beispiel.com', 'name' => 'Bob']
];

foreach ($users as $user) {
  $mail->addAddress($user['email'], $user['name']); // E-Mail jedes Benutzers korrekt hinzufügen
  $mail->isHTML(true); // HTML aktivieren für den Body
  $mail->Body = "<h2>Hallo, {$user['name']}!</h2> <p>Wie geht es Ihnen?</p>";
  $mail->AltBody = "Hallo, {$user['name']}! \nWie geht es Ihnen?";

  try {
      if ($mail->send()) {
          echo "Nachricht gesendet an: {$user['email']}\n";
      } else {
          echo "Mailer Error ({$user['email']}): {$mail->ErrorInfo}\n";
      }
  } catch (Exception $e) {
      echo "Mailer Error ({$user['email']}): {$e->getMessage()}\n";
  }
  $mail->clearAddresses(); // Adressen für die nächste Iteration löschen
}

$mail->smtpClose(); // Optional die SMTP-Verbindung schließen

Profi-Tipp:

  • Sie können auch addCC() und addBCC() verwenden, um Empfänger jeweils als Kopie (CC) und Blindkopie (BCC) hinzuzufügen.

E-Mails mit Anhängen senden

Wenn es darum geht, Anhänge mit PHPMailer zu senden, haben Sie zwei Möglichkeiten:

  • Datei von Ihrem Dateisystem anhängen

Mit dieser Option sollten Sie Ihre Dateien im selben Verzeichnis wie das Skript speichern.

Um eine Datei anzuhängen, müssen Sie lediglich ihren Pfad angeben. Darüber hinaus können Sie einen Dateinamen hinzufügen, dies ist jedoch optional, da das Skript den tatsächlichen Namen Ihrer Datei verwendet:

$mail->addAttachment('pfad/zu/rechnung1.pdf', 'rechnung1.pdf');

Wenn Sie also beispielsweise dieses Skript aufrufen, hängt PHPMailer die Datei im Pfad pfad/zu/rechnung1.pdf an die E-Mail an. Der zweite Parameter, rechnung1.pdf, ist optional und gibt den Dateinamen an, wie er dem Empfänger angezeigt wird. Wenn Sie ihn nicht angeben, verwendet PHPMailer den ursprünglichen Dateinamen.

Wenn Sie eine weitere Datei hinzufügen möchten, wiederholen Sie den Befehl:

$mail->addAttachment('pfad/zo/kalkulation1.xlsx', 'kalkulation1.xlsx');
  • String-Anhang hinzufügen

Diese Methode ermöglicht es Ihnen, Daten anzuhängen, ohne sie zuerst als physische Datei auf Ihrem Dateisystem speichern zu müssen. Im Wesentlichen hängen Sie die in einer Variablen gespeicherten Daten an. Sie können beispielsweise eine Datei aus einer Datenbank extrahieren, z. B. BLOB (Binary Large Object), sodass Sie sie nicht als Datei speichern müssen.

Verwenden Sie dazu den Befehl addStringAttachment(), der den Inhalt und den Dateinamen übergeben sollte:

$mysql_data = $mysql_row['blob_data'];
$mail->addStringAttachment($mysql_data, 'db_daten.db');

Dies ist ein Beispiel für das Hinzufügen von als BLOB gespeicherten Daten aus einer MySQL-Datenbank.

Sie können auch eine Remote-URL verwenden, wie folgt:

$mail->addStringAttachment(file_get_contents($url), 'meinedatei.pdf');

E-Mails mit eingebettetem Bild senden

Um eine E-Mail mit einem eingebetteten Bild zu senden, verwende ich CID-Anhänge, wie folgt:

$mail->addEmbeddedImage('pfad/zu/bilddatei.jpg', 'bild_cid');
$mail->isHTML(true);
$mail->Body = '<img src="cid:bild_cid">';

Und hier ist ein vollständiges Code-Snippet-Beispiel, um Ihnen ein besseres Bild zu vermitteln:

<?php
use PHPMailer\PHPMailer\PHPMailer;
require 'path/to/composer/vendor/autoload.php';

$mail = new PHPMailer(true); // Aktiviert Ausnahmen

$mail->isSMTP();
$mail->Host = 'live.smtp.mailtrap.io';
$mail->SMTPAuth = true;
$mail->Username = 'von Mailtrap generierten einfügen';
$mail->Password = 'von Mailtrap generierten einfügen';
$mail->SMTPSecure = 'tls';
$mail->Port = 587;

$mail->setFrom('von@beispiel.com', 'Vorname Nachname');
$mail->addReplyTo('anwen@beispiel.com', 'Max Mustermann');
$mail->addAddress('empfaenger@beispiel.com', 'Empfänger Name'); // Empfänger angeben

$mail->isHTML(true);
$mail->Subject = "PHPMailer SMTP-Test";
$mail->addEmbeddedImage('pfad/zu/bilddatei.jpg', 'bild_cid'); // Pfad zu Ihrem Bild und eine CID angeben
$mail->Body = '<img src="cid:bild_cid"> Mail-Body in HTML'; // Verwenden Sie die CID als src-Attribut in Ihrem img-Tag
$mail->AltBody = 'Dies ist die Plain-Text-Version des E-Mail-Inhalts';

if(!$mail->send()){
    echo 'Nachricht konnte nicht gesendet werden.';
    echo 'Mailer Error: ' . $mail->ErrorInfo;
}else{
    echo 'Nachricht wurde gesendet';
}

Asynchroner E-Mail-Versand

Obwohl PHPMailer von Natur aus synchron ist und keine asynchronen Operationen wie z. B. Node.js unterstützt, können wir die Funktion exec() verwenden, um ein PHP-Skript aufzurufen, das die E-Mail im Hintergrund sendet.

Damit diese Methode funktioniert, müssen Sie die PHP CLI (Kommandozeilenschnittstelle) installieren.

Hier ist das Skript sendEmail.php, das Sie verwenden können:

<?php
use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\Exception;

require 'path/to/vendor/autoload.php'; // Passen Sie den Pfad bei Bedarf an

$mail = new PHPMailer(true);

// SMTP-Konfiguration
$mail->isSMTP();
$mail->Host = 'smtp.beispiel.com'; // Geben Sie Haupt- und Backup-SMTP-Server an
$mail->SMTPAuth = true; // SMTP-Authentifizierung aktivieren
$mail->Username = 'benutzer@beispiel.com'; // SMTP-Benutzername
$mail->Password = 'geheim'; // SMTP-Passwort
$mail->SMTPSecure = 'tls'; // TLS-Verschlüsselung aktivieren, `ssl` wird auch akzeptiert
$mail->Port = 587; // TCP-Port für die Verbindung

// E-Mail-Einstellungen
$mail->setFrom('von@beispiel.com', 'Mailer');
$mail->addAddress('empfaenger@beispiel.com', 'Empfänger Name'); // Einen Empfänger hinzufügen
$mail->isHTML(true); // E-Mail-Format auf HTML setzen
$mail->Subject = 'Hier ist der Betreff';
$mail->Body    = 'Dies ist der HTML-Nachrichtentext <b>in fett!</b>';
$mail->AltBody = 'Dies ist der Textkörper in Plain-Text für Nicht-HTML-Mail-Clients';

try {
    $mail->send();
    echo 'Nachricht wurde gesendet';
} catch (Exception $e) {
    echo "Nachricht konnte nicht gesendet werden. Mailer Error: {$mail->ErrorInfo}";
}

Um dieses Skript auszuführen, verwenden Sie den folgenden Befehl:

exec("php /Absolute/path/to/sendEmail.php > /dev/null &");

Hinweise:

  • Sie müssen sicherstellen, dass der Pfad zur ausführbaren PHP CLI-Datei (php) korrekt angegeben ist.
    • In einigen Fällen und Umgebungen müssen Sie möglicherweise den vollständigen Pfad zur CLI-Binärdatei verwenden (z. B. /usr/bin/php).
  • Vergessen Sie nicht, die PHP-Konfiguration Ihres Servers zu überprüfen, um sicherzustellen, dass Funktionen wie exec() nicht deaktiviert sind, da dies aus Sicherheitsgründen häufig in Shared-Hosting-Umgebungen der Fall ist.
    • Die Direktive, die dies steuert, ist die disable_functions-Direktive in php.ini.

Wie man Massen-E-Mails sendet

Bis zu diesem Punkt haben wir den Transaktionalen Stream von Mailtrap verwendet, aber jetzt verwenden wir die Zugangsdaten des Massenversand-Streams, mit dem wir E-Mails gleichzeitig an viele Empfänger senden können.

Melden Sie sich also bei Ihrem Mailtrap-Konto an und navigieren Sie zum Tab „SMTP Settings“, wo Sie die Zugangsdaten für den Massenversand-Stream auf der rechten Seite des Fensters finden.

Ein Screenshot der Mailtrap Massenversand-Stream SMTP-Zugangsdaten

Fügen Sie dann diese Zugangsdaten in das folgende Skript ein, das Sie zum Senden von Massen-E-Mails verwenden können:

<?php
use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\Exception;

require 'vendor/autoload.php'; // Pfad zur Composer autoload-Datei

$mail = new PHPMailer(true);

try {
    //Server settings
    $mail->isSMTP();
    $mail->Host       = 'bulk.smtp.mailtrap.io'; // SMTP-Server zum Senden festlegen
    $mail->SMTPAuth   = true;               // SMTP-Authentifizierung aktivieren
    $mail->Username   = 'ihr_smtp_benutzername'; // SMTP-Benutzername
    $mail->Password   = 'ihr_smtp_passwort'; // SMTP-Passwort
    $mail->SMTPSecure = PHPMailer::ENCRYPTION_STARTTLS; // TLS-Verschlüsselung aktivieren; 
    $mail->Port       = 587; // TCP-Port für die Verbindung

    // Absender- und Antwortadresse
    $mail->setFrom('von@beispiel.com', 'Mailer');
    $mail->addReplyTo('antwortan@beispiel.com', 'Mailer');

    // Inhalt
    $mail->isHTML(true); // E-Mail-Format auf HTML setzen
    
    // Empfängerliste
    $recipients = [
        ['email' => 'person1@beispiel.com', 'name' => 'Person Eins'],
        ['email' => 'person2@beispiel.com', 'name' => 'Person Zwei'],
        // Fügen Sie bei Bedarf weitere Empfänger hinzu
    ];

    foreach ($recipients as $recipient) {
        $mail->addAddress($recipient['email'], $recipient['name']); // Einen Empfänger hinzufügen

        // Personalisieren Sie die Nachricht
        $mail->Subject = 'Hier ist der Betreff';
        $mail->Body    = 'Dies ist der HTML-Nachrichtentext <b>in fett!</b>';
        $mail->AltBody = 'Dies ist der Textkörper in Plain-Text für Nicht-HTML-Mail-Clients';

        $mail->send();
        $mail->clearAddresses(); // Adressen für die nächste Iteration löschen
    }

    echo "Nachrichten wurden gesendet";
} catch (Exception $e) {
    echo "Nachricht konnte nicht gesendet werden. Mailer Error: {$mail->ErrorInfo}";
}

Auf diese Weise können wir E-Mails an mehrere Empfänger senden, ohne die SMTP-Verbindung für jede Mail öffnen und schließen zu müssen. Es ist effizienter, als beispielsweise für jede Mail eine neue PHPMailer-Instanz zu erstellen.

Wenn Sie jedoch mit einem großen E-Mail-Volumen arbeiten, können Sie ein Job-Warteschlangensystem wie RabbitMQ, Beanstalkd, Redis usw. verwenden.

Als Beispiel zeige ich Ihnen, wie Sie es mit Redis einrichten.

Installieren Sie zuerst einen PHP-Client für Redis, predis/predis, über Composer, indem Sie den folgenden Befehl im Stammverzeichnis Ihres Projekts ausführen, wo sich Ihre composer.json-Datei befindet:

composer require predis/predis

Dann benötigen wir ein Job-Producer-Skript, das E-Mail-Jobs in eine Redis-Liste pusht. Beachten Sie hier, dass jeder Job ein JSON-kodierter String mit allen notwendigen Daten zum Senden einer E-Mail sein kann:

require 'vendor/autoload.php';

use Predis\Client;

$redis = new Client();

while (true) {
    // Versuch, einen Auftrag aus der ‚emailQueue‘-Liste zu löschen, Blockierung für bis zu 5 Sekunden, wenn sie leer ist
    $job = $redis->brpop(['emailQueue'], 5);

    if ($job) {
        // Auftragsformat: [$listName, $jobData]
        $emailDataJson = $job[1];
        $emailData = json_decode($emailDataJson, true);

        // Verarbeiten Sie die emailData...
        // Senden Sie die E-Mail mit PHPMailer, protokollieren Sie Erfolg/Misserfolg, usw.

        echo "Einen Auftrag aus der emailQueue verarbeitet: " . $emailDataJson . "\n";
    } else {
        // Innerhalb der Timeout-Periode war kein Auftrag in der Warteschlange verfügbar
        echo "Warten auf Jobs...\n";
    }
}

Zuletzt erstellen wir ein Worker-Skript und stellen sicher, dass PHPMailer mit den Zugangsdaten des Massenversand-Streams konfiguriert ist:

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

use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\Exception;
use Predis\Client;

// Redis-Client initialisieren
$redis = new Client();

//  Logger-Funktion
function logError($message) {
    // Fehler an eine Logdatei anhängen
    file_put_contents('email_errors.log', $message . PHP_EOL, FILE_APPEND);
}

// Funktion zum Senden von E-Mails, gibt bei Erfolg true oder bei Fehler false zurück
function sendEmail($emailData) {
    $mail = new PHPMailer(true);

    try {
        // SMTP-Konfiguration
        $mail->isSMTP();
        $mail->Host       = 'bulk.smtp.mailtrap.io';
        $mail->SMTPAuth   = true;
        $mail->Username   = 'ihr_smtp_benutzername';
        $mail->Password   = 'ihr_smtp_passwort;
        $mail->SMTPSecure = PHPMailer::ENCRYPTION_STARTTLS;
        $mail->Port       = 587;

        // Empfänger
        $mail->setFrom('von@beispiel.com', 'Mailer');
        $mail->addAddress($emailData['email']); // Empfänger

        // Inhalt
        $mail->isHTML(true); // E-Mail-Format auf HTML setzen
        $mail->Subject = $emailData['subject'];
        $mail->Body    = $emailData['body'];

        $mail->send();
        return true;
    } catch (Exception $e) {
        // Den spezifischen Fehler protokollieren
        logError("E-Mail konnte nicht an {$emailData['email']} gesendet werden. Mailer Error: " . $mail->ErrorInfo);
        return false;
    }
}

// Wiederholungsrichtlinie
$maxRetries = 3; // Maximale Anzahl von Wiederholungsversuchen für einen fehlgeschlagenen E-Mail-Sendeversuch
$retryDelay = 2; // Anfängliche Verzögerung zwischen Wiederholungsversuchen in Sekunden

while ($emailDataJson = $redis->rpop('emailQueue')) {
    $emailData = json_decode($emailDataJson, true);
    $attempt = 0;

    while (!sendEmail($emailData) && $attempt < $maxRetries) {
        $attempt++;
        // Exponentielles Backoff
        sleep($retryDelay * pow(2, $attempt - 1));
    }

    if ($attempt == $maxRetries) {
        // Endgültige Protokollierung für E-Mails, die nach allen Wiederholungsversuchen fehlgeschlagen sind
        logError("Endgültiger Fehler: E-Mail konnte nach $maxRetries Versuchen nicht an {$emailData['email']} gesendet werden.");
    } else {
        echo "E-Mail gesendet an {$emailData['email']}\n";
    }
}

Profi-Tipp: Wenn Sie sich für Redis entscheiden, empfehle ich Ihnen, einen Prozessmanager wie Supervisor zu verwenden, der das Worker-Skript am Laufen hält und es automatisch neu startet, wenn es abstürzt.

E-Mails über E-Mail-API senden

Der beste Weg für API-basierten E-Mail-Versand ist die Verwendung des offiziellen PHP-SDK eines E-Mail-Dienstanbieters, da PHPMailer nicht für diesen Zweck konzipiert ist. Glücklicherweise können wir uns auf die Mailtrap Email API/SMTP API verlassen, da sie einen PHP-Client bietet und es Ihnen ermöglicht, Mailtrap einfach in Ihre App zu integrieren.

Um mit dem Senden von E-Mails über die Mailtrap Email API/SMTP API zu beginnen, müssen Sie zuerst ein Konto erstellen und dann Ihre Domain hinzufügen und verifizieren.

Installieren Sie dann das offizielle Mailtrap PHP SDK über Composer.

Sie können einen der folgenden Befehle verwenden, um schnell loszulegen:

# Mit Symfony http client (empfohlen)
composer require railsware/mailtrap-php symfony/http-client nyholm/psr7

# Oder mit Guzzle http client
composer require railsware/mailtrap-php guzzlehttp/guzzle php-http/guzzle7-adapter

Hinweis: Da der Mailtrap API Client die PSR-18 Client-Abstraktion verwendet und somit nicht fest an eine Bibliothek gekoppelt ist, die HTTP-Nachrichten sendet, haben Sie die Flexibilität zu wählen, welchen HTTP-Client Sie verwenden möchten.

Und um eine Plain-Text-E-Mail mit dem SDK zu senden, verwenden Sie einfach das folgende Code-Snippet:

<?php

use Mailtrap\Config;
use Mailtrap\EmailHeader\CategoryHeader;
use Mailtrap\EmailHeader\CustomVariableHeader;
use Mailtrap\Helper\ResponseHelper;
use Mailtrap\MailtrapClient;
use Symfony\Component\Mime\Address;
use Symfony\Component\Mime\Email;
use Symfony\Component\Mime\Header\UnstructuredHeader;

require __DIR__ . '/vendor/autoload.php';

// Your API token from here https://mailtrap.io/api-tokens
$apiKey = getenv('MAILTRAP_API_KEY');
$mailtrap = new MailtrapClient(new Config($apiKey));

$email = (new Email())
  ->from(new Address('beispiel@ihre-domain-hier.com', 'Mailtrap Test'))
  ->replyTo(new Address('antwort@ihre-domain-hier.com'))
  ->to(new Address('email@beispiel.com', 'Jon')) // Einzelner Empfänger
  ->priority(Email::PRIORITY_HIGH)
  ->subject('Best Practices zum Erstellen von HTML-E-Mails')
  ->text("Hey! Lernen Sie die Best Practices zum Erstellen von HTML-E-Mails und spielen Sie mit vorgefertigten Vorlagen. Mailtrap's Leitfaden zum Erstellen von HTML-E-Mails ist live auf unserem Blog");

// Header
$email->getHeaders()
    ->addTextHeader('X-Message-Source', 'domain.com')
    ->add(new UnstructuredHeader('X-Mailer', 'Mailtrap PHP Client')); // dasselbe wie addTextHeader

// Benutzerdefinierte Variablen
$email->getHeaders()
    ->add(new CustomVariableHeader('user_id', '45982'))
    ->add(new CustomVariableHeader('batch_id', 'PSJ-12'));

// Kategorie (sollte nur eine sein)
$email->getHeaders()
    ->add(new CategoryHeader('Integration Test'));

try {
    $response = $mailtrap->sending()->emails()->send($email); // E-Mail-Versand-API (echt)
    
    var_dump(ResponseHelper::toArray($response)); // body (array)
} catch (Exception $e) {
    echo 'Ausnahme abgefangen: ',  $e->getMessage(), "\n";
}

Hinweis:

  • Stellen Sie sicher, dass Sie Ihren API-Schlüssel kopieren und in das Skript einfügen. Sie finden ihn im Tab SMTP/API Settings unter dem Abschnitt Sending Domains.

HTML-E-Mail senden

Um eine HTML-E-Mail zu senden, ändern Sie einfach das Skript für Plain-Text-E-Mails, indem Sie die Methode ->html() hinzufügen.

Im folgenden Codebeispiel zeige ich Ihnen, wie Sie eine HTML-E-Mail senden, die Sie an mehrere Empfänger senden und Dateien anhängen können:

<?php

use Mailtrap\Config;
use Mailtrap\EmailHeader\CategoryHeader;
use Mailtrap\EmailHeader\CustomVariableHeader;
use Mailtrap\Helper\ResponseHelper;
use Mailtrap\MailtrapClient;
use Symfony\Component\Mime\Address;
use Symfony\Component\Mime\Email;
use Symfony\Component\Mime\Header\UnstructuredHeader;
use Symfony\Component\Mime\Part\DataPart;

require __DIR__ . '/vendor/autoload.php';

// Your API token from here https://mailtrap.io/api-tokens


$apiKey = “MAILTRAP_API_KEY”;
$mailtrap = new MailtrapClient(new Config($apiKey));

$email = (new Email())
    ->from(new Address('beispiel@ihre-domain-hier.com', 'Mailtrap Test'))
    ->replyTo(new Address('antwort@ihre-domain-hier.com'))
    ->to(new Address('email@beispiel.com', 'Jon'))
    ->priority(Email::PRIORITY_HIGH)
    ->cc('mailtrapqa@ beispiel.com')
    ->addCc('staging@ beispiel.com')
    ->bcc('mailtrapdev@ beispiel.com')
    ->subject('Best Practices zum Erstellen von HTML-E-Mails')
    ->text('Hey! Lernen Sie die Best Practices zum Erstellen von HTML-E-Mails und spielen Sie mit vorgefertigten Vorlagen. Mailtrap\'s Leitfaden zum Erstellen von HTML-E-Mails ist live auf unserem Blog')
    ->html(
        '<html>
        <body>
        <p><br>Hey</br>
        Lernen Sie die Best Practices zum Erstellen von HTML-E-Mails und spielen Sie mit vorgefertigten Vorlagen.</p>
        <p><a href="https://mailtrap.io/de/blog/build-html-email/">Mailtrap\'s Leitfaden zum Erstellen von HTML-E-Mails</a> ist live auf unserem Blog</p>
        <img src="cid:logo">
        </body>
    </html>'
    )
    ->embed(fopen('https://mailtrap.io/wp-content/uploads/2021/04/mailtrap-new-logo.svg', 'r'), 'logo', 'image/svg+xml');

// Eine Datei anhängen
$email->attachFromPath('/pfad/zu/ihrer/datei.pdf', 'Dateiname.pdf', 'application/pdf');

// Headers
$email->getHeaders()
    ->addTextHeader('X-Message-Source', 'domain.com')
    ->add(new UnstructuredHeader('X-Mailer', 'Mailtrap PHP Client')); // dasselbe wie addTextHeader

// Benutzerdefinierte Variablen
$email->getHeaders()
    ->add(new CustomVariableHeader('user_id', '45982'))
    ->add(new CustomVariableHeader('batch_id', 'PSJ-12'));

// Kategorie (sollte nur eine sein)
$email->getHeaders()
    ->add(new CategoryHeader('Integration Test'));

try {
    $response = $mailtrap->sending()->emails()->send($email); // E-Mail-Versand-API (echt)
    
    var_dump(ResponseHelper::toArray($response)); // body (array)
} catch (Exception $e) {
    echo 'Ausnahme abgefangen: ',  $e->getMessage(), "\n";
}
E-Mails kostenlos mit Mailtrap senden

E-Mail an mehrere Empfänger senden

Um eine E-Mail an mehrere Empfänger zu senden, fügen Sie einfach die Adressen zu den Feldern to, cc und bcc des Codes hinzu. Die im Skript verwendete Symfony Email-Klasse ermöglicht es uns, mehrere Empfänger in jedem der Felder hinzuzufügen.

Hier ist ein Beispiel für einen Code, den Sie verwenden können:

<?php

use Mailtrap\Config;
use Mailtrap\EmailHeader\CategoryHeader;
use Mailtrap\EmailHeader\CustomVariableHeader;
use Mailtrap\Helper\ResponseHelper;
use Mailtrap\MailtrapClient;
use Symfony\Component\Mime\Address;
use Symfony\Component\Mime\Email;
use Symfony\Component\Mime\Header\UnstructuredHeader;

require __DIR__ . '/vendor/autoload.php';

// Your API token from here https://mailtrap.io/api-tokens
$apiKey = getenv('MAILTRAP_API_KEY');
$mailtrap = new MailtrapClient(new Config($apiKey));

$email = (new Email())
  ->from(new Address('beispiel@ihre-domain-hier.com', 'Mailtrap Test'))
  ->replyTo(new Address('antwort@ihre-domain-hier.com'))
  ->to(new Address('email@beispiel.com', 'Jon')) // Erster Empfänger
  ->addTo(new Address('email2@beispiel.com', 'Jane')) // Zweiter Empfänger
  ->priority(Email::PRIORITY_HIGH)
  ->cc('mailtrapqa@beispiel.com')
  ->addCc('staging@beispiel.com')
  ->bcc('mailtrapdev@beispiel.com')
  ->subject('Best Practices zum Erstellen von HTML-E-Mails')
  ->text("Hey! Lernen Sie die Best Practices zum Erstellen von HTML-E-Mails und spielen Sie mit vorgefertigten Vorlagen. Mailtrap's Leitfaden zum Erstellen von HTML-E-Mails ist live auf unserem Blog");

// Header
$email->getHeaders()
    ->addTextHeader('X-Message-Source', 'domain.com')
    ->add(new UnstructuredHeader('X-Mailer', 'Mailtrap PHP Client')); // dasselbe wie addTextHeader

// Benutzerdefinierte Variablen
$email->getHeaders()
    ->add(new CustomVariableHeader('user_id', '45982'))
    ->add(new CustomVariableHeader('batch_id', 'PSJ-12'));

// Kategorie (sollte nur eine sein)
$email->getHeaders()
    ->add(new CategoryHeader('Integration Test'));

try {
    $response = $mailtrap->sending()->emails()->send($email); // Email sending API (real)
    
    var_dump(ResponseHelper::toArray($response)); // body (array)
} catch (Exception $e) {
    echo 'Ausnahme abgefangen: ',  $e->getMessage(), "\n";
}

E-Mails mit Anhängen senden

Um eine E-Mail mit Anhängen zu senden, können wir die Methode attachFromPath() verwenden, die von der Symfony Mime Email-Klasse bereitgestellt wird. Sie ermöglicht es uns, eine Datei anzuhängen, indem wir den Pfad zur Datei angeben.

Sie können den folgenden Code verwenden, um eine E-Mail mit angehängten Dateien zu senden:

<?php

use Mailtrap\Config;
use Mailtrap\EmailHeader\CategoryHeader;
use Mailtrap\EmailHeader\CustomVariableHeader;
use Mailtrap\Helper\ResponseHelper;
use Mailtrap\MailtrapClient;
use Symfony\Component\Mime\Address;
use Symfony\Component\Mime\Email;
use Symfony\Component\Mime\Header\UnstructuredHeader;

require __DIR__ . '/vendor/autoload.php';

// Ihr API-Token von hier https://mailtrap.io/de/api-tokens


$apiKey = “MAILTRAP_API_KEY”;
$mailtrap = new MailtrapClient(new Config($apiKey));

// Initialisieren Sie das E-Mail-Objekt
$email = (new Email())
  ->from(new Address('beispiel@ihre-domain-hier.com', 'Mailtrap Test'))
  ->replyTo(new Address('antwort@ihre-domain-hier.com'))
  ->to(new Address('email@beispiel.com', 'Jon')) // Für mehrere Empfänger wiederholen Sie diese Zeile mit verschiedenen Adressen
  ->priority(Email::PRIORITY_HIGH)
  ->subject('Best Practices zum Erstellen von HTML-E-Mails')
  ->text("Hey! Lernen Sie die Best Practices zum Erstellen von HTML-E-Mails und spielen Sie mit vorgefertigten Vorlagen. Mailtrap's Leitfaden zum Erstellen von HTML-E-Mails ist live auf unserem Blog");

// Eine Datei anhängen
$email->attachFromPath('/pfad/zu/ihrer/datei.pdf', 'Dateiname.pdf', 'application/pdf');

// Header und benutzerdefinierte Variablen wie zuvor definiert
$email->getHeaders()
    ->addTextHeader('X-Message-Source', 'domain.com')
    ->add(new UnstructuredHeader('X-Mailer', 'Mailtrap PHP Client'))
    ->add(new CustomVariableHeader('user_id', '45982'))
    ->add(new CustomVariableHeader('batch_id', 'PSJ-12'))
    ->add(new CategoryHeader('Integration Test'));

try {
    $response = $mailtrap->sending()->emails()->send($email); // Senden Sie die E-Mail über Mailtrap
    var_dump(ResponseHelper::toArray($response)); // Zeigen Sie die Antwort an
} catch (Exception $e) {
    echo 'Ausnahme abgefangen: ',  $e->getMessage(), "\n";
}

E-Mails mit eingebettetem Bild senden

Das Senden von E-Mails mit einem eingebetteten Bild ist ebenfalls recht einfach, da wir die Methode ->embed() als Teil des Email-Objekts verwenden können. Die Methode ermöglicht es uns im Wesentlichen, Bilder direkt in den HTML-Body der E-Mail einzubinden, auf die über eine Content-ID (CID) verwiesen werden kann.

<?php

use Mailtrap\Config;
use Mailtrap\EmailHeader\CategoryHeader;
use Mailtrap\EmailHeader\CustomVariableHeader;
use Mailtrap\Helper\ResponseHelper;
use Mailtrap\MailtrapClient;
use Symfony\Component\Mime\Address;
use Symfony\Component\Mime\Email;
use Symfony\Component\Mime\Header\UnstructuredHeader;

require __DIR__ . '/vendor/autoload.php';

// Ihr API-Token von hier https://mailtrap.io/de/api-tokens
$apiKey = getenv('MAILTRAP_API_KEY');
$mailtrap = new MailtrapClient(new Config($apiKey));

// Initialisieren Sie das E-Mail-Objekt mit den notwendigen Details
$email = (new Email())
    ->from(new Address('beispiel@ihre-domain-hier.com', 'Mailtrap Test'))
    ->replyTo(new Address('antwort@ihre-domain-hier.com'))
    ->to(new Address('email@beispiel.com', 'Empfänger Name'))
    ->subject('HTML E-Mail mit eingebettetem Bild')
    ->html('<html><body>Hier ist ein eingebettetes Bild: <img src="cid:unique-image-id"></body></html>');

// Betten Sie das Bild ein und weisen Sie ihm eine CID zu
$imagePath = '/pfad/zu/ihrem/bild.jpg'; // Stellen Sie sicher, dass Sie den korrekten Pfad zu Ihrer Bilddatei verwenden
$email->embedFromPath($imagePath, 'unique-image-id');

// (Optional) Fügen Sie zusätzliche Konfigurationen wie CC, BCC, Textteil usw. hinzu.

try {
    $response = $mailtrap->sending()->emails()->send($email); // Senden Sie die E-Mail über Mailtrap
    var_dump(ResponseHelper::toArray($response)); // Zeigen Sie die Antwort an
} catch (Exception $e) {
    echo 'Ausnahme abgefangen: ',  $e->getMessage(), "\n";
}

Tipp: Vergessen Sie nicht, /pfad/zu/ihrem/bild.jpg durch den tatsächlichen Pfad zu Ihrer Bilddatei zu ersetzen.

Asynchroner E-Mail-Versand

Um HTTP-Anfragen asynchron zu senden, können Sie die curl_multi-Funktionen von PHP verwenden.

Die Funktion curl_multi_init() ist Teil der cURL-Erweiterung, die es Ihnen ermöglicht, mehrere HTTP-Anfragen gleichzeitig zu stellen. Wenn diese Erweiterung jedoch nicht aktiviert oder installiert ist, können Sie weder sie noch andere cURL-Funktionen verwenden.

Um dieses Problem zu beheben, müssen Sie die cURL-Erweiterung in Ihrer PHP-Installation aktivieren. Hier sind die Schritte dazu für verschiedene Betriebssysteme (Beispiel für Debian/Ubuntu):

sudo apt-get update
sudo apt-get install php-curl

Nach der Installation müssen Sie die Erweiterung möglicherweise manuell aktivieren, indem Sie Ihre php.ini-Datei bearbeiten, obwohl sie normalerweise automatisch aktiviert wird. Falls erforderlich, suchen Sie Ihre php.ini-Datei (der Speicherort hängt von Ihrer PHP-Version und Einrichtung ab, ein üblicher Pfad könnte /etc/php/7.4/cli/php.ini für PHP 7.4 CLI sein) und stellen Sie sicher, dass die Zeile extension=curl nicht auskommentiert ist (entfernen Sie das Semikolon am Anfang der Zeile, falls vorhanden).

Sie müssen den Apache-Server neu starten.

sudo service apache2 restart

Hier ist ein Codebeispiel, wie Sie dies tun könnten:

<?php

// Initialisieren Sie den cURL Multi-Handle
$multiCurl = curl_multi_init();

// Array zum Verfolgen der einzelnen cURL-Handles
$curlHandles = [];

// Beispiel: Mehrere E-Mail-Daten (zur Demonstration wird dieselbe E-Mail an mehrere Empfänger gesendet)
$emailDatas = [
    [
        'from' => ['email' => 'von@beispiel.com',
        'to' => 'empfaenger1@beispiel.com']],
        'subject' => 'Hier ist der Betreff',
        'text' => 'Dies ist der Plain-Text-Nachrichtentext',
        'html' => '<p>Dies ist der HTML-Nachrichtentext</p>',
    ],
    [
        'from' => ['email' => 'von@beispiel.com'],
        'to' => [['email' => 'empfaenger2@beispiel.com']],
        'subject' => 'Hier ist der Betreff',
        'text' => 'Dies ist der Plain-Text-Nachrichtentext',
        'html' => '<p>Dies ist der HTML-Nachrichtentext</p>',
    ]
    // Fügen Sie bei Bedarf weitere hinzu
];

foreach ($emailDatas as $emailData) {
    // Bereiten Sie den cURL-Handle für jede E-Mail vor
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, 'https://api.mailtrap.io/v1/messages'); // Use the correct API endpoint
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($emailData));
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'Content-Type: application/json',
        'Authorization: Bearer ihr_mailtrap_ap_token', // Verwenden Sie Ihr aktuelles Mailtrap API-Token
    ]);

    // Fügen Sie den cURL-Handle zum Multi-Handle hinzu
    curl_multi_add_handle($multiCurl, $ch);
    $curlHandles[] = $ch; // Behalten Sie die Handles im Auge
}

// Führen Sie den cURL Multi-Handle aus
$active = null;
do {
    $mrc = curl_multi_exec($multiCurl, $active);
    if ($mrc != CURLM_OK) {
        // Behandeln Sie den cURL Multi-Fehler
        break;
    }
    // Warten Sie auf Aktivität bei einer beliebigen curl_multi-Verbindung
    if (curl_multi_select($multiCurl) == -1) {
        usleep(100);
    }
} while ($active);

// Lesen und verarbeiten Sie die Antworten
foreach ($curlHandles as $handle) {
    $response = curl_multi_getcontent($handle);
    // Verarbeiten Sie Ihre Antwort hier. Überprüfen Sie den HTTP-Statuscode, den Antwortkörper usw.
    echo $response . PHP_EOL;

    // Entfernen und schließen Sie den Handle
    curl_multi_remove_handle($multiCurl, $handle);
    curl_close($handle);
}

// Schließen Sie den cURL Multi-Handle
curl_multi_close($multiCurl);

Wie man Massen-E-Mails sendet

Wenn Sie planen, große Mengen von E-Mails in PHP mit der Mailtrap Email API/SMTP API zu senden, ist Ihre beste Wahl die Verwendung eines Job-Warteschlangensystems.

Aber zuerst müssen wir unseren Massenversand-Stream einrichten. Navigieren Sie also zum Tab SMTP/API Settings in Ihrem Mailtrap-Konto und wählen Sie API im Fenster Massenversand-Stream. Dort finden Sie den Host und das API-Token, die Sie kopieren und in Ihr PHP-Skript einfügen müssen.

Mailtrap API Massenversand-Stream Einstellungen

Mit diesen eingerichteten Zugangsdaten für den Massenversand-Stream können Sie so gut wie jedes Job-Warteschlangensystem verwenden, wie RabbitMQ, Beanstalkd usw. Für dieses Tutorial zeige ich Ihnen, wie Sie Redis einrichten.

Falls noch nicht geschehen, fügen Sie Redis zu Ihrem Projekt hinzu:

composer require predis/predis

Um einen Job mit allen notwendigen Informationen in Redis in die Warteschlange zu stellen, verwenden Sie das folgende PHP-Code-Snippet:

require 'vendor/autoload.php';

$predis = new Predis\Client();

$emailData = [
    'from' => 'von@beispiel.com'],
    'to' => [['email' => 'empfaenger@beispiel.com']],
    'subject' => 'Ihr Betreff hier',
    'html' => '<p>Ihr HTML-Inhalt hier</p>',
    'text' => 'Ihr Plain-Text hier',
    // Fügen Sie alle anderen für die E-Mail erforderlichen Daten hinzu
];

// Stellen Sie die E-Mail-Daten zur späteren Verarbeitung in die Warteschlange
$predis->lpush('emailQueue', json_encode($emailData));

Verwenden Sie schließlich dieses PHP-Skript, das die Redis-Warteschlange kontinuierlich auf neue E-Mail-Aufgaben überwacht, sie aus der Warteschlange löscht und über die Mailtrap Email API/SMTP API sendet:

require 'vendor/autoload.php';

$predis = new Predis\Client();
$mailtrapConfig = new Mailtrap\Config('ihr_mailtrap_api_schluessel');
$mailtrapClient = new Mailtrap\MailtrapClient($mailtrapConfig);

while (true) {
    // Blockieren, bis eine E-Mail-Aufgabe verfügbar ist (0 = unbegrenzte Wartezeit) 
    $emailTask = $predis->brpop('emailQueue', 0);
    
    if ($emailTask) {
        $emailData = json_decode($emailTask[1], true); // $emailTask[1] enthält die E-Mail-Daten
        
        // Senden Sie die E-Mail mit Mailtrap Email API/SMTP
        $email = (new Symfony\Component\Mime\Email())
            ->from(new Address($emailData['from']))
            ->to(new Address($emailData['to']))
            ->subject($emailData['subject'])
            ->html($emailData['html'])
            ->text($emailData['text']);
        
        try {
            $response = $mailtrapClient->sending()->emails()->send($email);
            echo "E-Mail gesendet: ", var_dump($response), "\n";
        } catch (Exception $e) {
            echo "Fehler beim Senden der E-Mail: ", $e->getMessage(), "\n";
        }
    }
}

Und vergessen Sie nicht, diesen Worker als Hintergrundprozess oder als Aufgabe in einem Prozessmanager wie Supervisor auszuführen.

E-Mails vor dem Senden testen

Bisher habe ich verschiedene Möglichkeiten zum Senden von Mails in PHP beschrieben, aber woher wissen Sie, ob Ihre E-Mail-Sendefunktion wie beabsichtigt funktioniert? Mit dem ganzen verwendeten Code ist es entscheidend, Ihre E-Mails in PHP zu testen, bevor Sie sie senden, unabhängig von der gewählten Sendemethode.

Das Testen Ihrer E-Mails ist Branchenstandard und eine untrennbare Phase des E-Mail-Sendezyklus. Glücklicherweise haben wir Sie mit der ganzheitlichen Email Sandbox-Lösung von Mailtrap abgedeckt.

Mit Mailtrap Email Testing können Sie Ihre E-Mails überprüfen, in der Vorschau anzeigen und Fehler beheben, bevor Sie sie versenden. Im Wesentlichen können Sie HTML/CSS Ihrer E-Mail überprüfen und fehlerhafte Codezeilen leicht erkennen und beheben/entfernen.

Mailtrap HTML Check

Diese Funktion ist entscheidend, um die Kompatibilität Ihrer vorlagenbasierten HTML/CSS-Designs zu überprüfen und sie zu perfektionieren, ohne sich Sorgen machen zu müssen, dass Sie die E-Mail produktiv senden.

Sie können Ihren Testprozess auch mit Ihren Teammitgliedern teilen, neue Projekte erstellen, mehrere Projekte hinzufügen und mehr mit Mailtrap Email Sandbox.

Mailtrap Projekte

Am wichtigsten ist, dass die Einrichtung von Mailtrap Email Testing ein Kinderspiel ist, da die Lösung einfach entweder über SMTP-Zugangsdaten oder das offizielle PHP SDK integriert werden kann.

SMTP

Um Ihre E-Mails mit einem Fake SMTP Server zu testen, müssen Sie lediglich die SMTP-Zugangsdaten von Mailtrap in Ihrer Transportmethode angeben:

Host: sandbox.smtp.mailtrap.io
Port: 25 or 465 or 587 or 2525
Benutzername: eindeutig für jedes Mailtrap-Postfach
Passwort: eindeutig für jedes Mailtrap-Postfach
TLS: Optional (STARTTLS auf allen Ports)

Sie können Mailtrap auch mit verschiedenen PHP-Bibliotheken und Frameworks integrieren. Hier ist zum Beispiel ein PHPMailer-Integrationsbeispiel:

$phpmailer = new PHPMailer();
$phpmailer->isSMTP();
$phpmailer->Host = 'sandbox.smtp.mailtrap.io';
$phpmailer->SMTPAuth = true;
$phpmailer->Port = 587;
$phpmailer->Username = '1a2b3c4d5e6f7g';
$phpmailer->Password = '1a2b3c4d5e6f7g';

Und so würde Ihr MAILER_DSN aussehen, wenn Sie Mailtrap beispielsweise mit dem Symfony-Framework integrieren würden:

MAILER_DSN=smtp://benutzername:passwort@sandbox.smtp.mailtrap.io:587/?encryption=tls

Sobald Sie Ihre Test-E-Mail versendet haben, können Sie nach wenigen Augenblicken den virtuellen Posteingang von Mailtrap überprüfen, und Sie sollten die folgende Nachricht sehen:

Mailtrap Email Sandbox HTML Vorschau
E-Mails kostenlos mit Mailtrap testen

API

Um die Mailtrap Email Testing API mit Ihrer PHP-basierten App zu integrieren, können Sie den folgenden Code verwenden:

?php

use Mailtrap\Config;
use Mailtrap\EmailHeader\CategoryHeader;
use Mailtrap\EmailHeader\CustomVariableHeader;
use Mailtrap\Helper\ResponseHelper;
use Mailtrap\MailtrapClient;
use Symfony\Component\Mime\Address;
use Symfony\Component\Mime\Email;
use Symfony\Component\Mime\Header\UnstructuredHeader;

require __DIR__ . '/../vendor/autoload.php';


/**********************************************************************************************************************
 ******************************************* EMAIL SANDBOX ************************************************************
 **********************************************************************************************************************
 */

/**
 * Email Sandbox API
 *
 * POST https://sandbox.api.mailtrap.io/api/send/{inbox_id}
 */
try {
    // Ihr API-Token von hier https://mailtrap.io/de/api-tokens
    $apiKey = getenv('MAILTRAP_API_KEY');
    $mailtrap = new MailtrapClient(new Config($apiKey));

    $email = (new Email())
        ->from(new Address('mailtrap@beispiel.com', 'Mailtrap Test'))
        ->replyTo(new Address('antwort@beispiel.com'))
        ->to(new Address('email@beispiel.com', 'Jon'))
        ->cc('mailtrapqa@beispiel.com')
        ->addCc('staging@beispiel.com')
        ->bcc('mailtrapdev@beispiel.com')
        ->subject('Best Practices zum Erstellen von HTML-E-Mails')
        ->text('Hey! Lernen Sie die Best Practices zum Erstellen von HTML-E-Mails und spielen Sie mit vorgefertigten Vorlagen. Mailtrap\'s Leitfaden zum Erstellen von HTML-E-Mails ist live auf unserem Blog')
        ->html(
            '<html>
            <body>
            <p><br>Hey</br>
            Lernen Sie die Best Practices zum Erstellen von HTML-E-Mails und spielen Sie mit vorgefertigten Vorlagen.</p>
            <p><a href="https://mailtrap.io/de/blog/build-html-email/">Mailtrap\'s Leitfaden zum Erstellen von HTML-E-Mails</a> ist live auf unserem Blog</p>
            <img src="cid:logo">
            </body>
        </html>'
        )
        ->embed(fopen('https://mailtrap.io/wp-content/uploads/2021/04/mailtrap-new-logo.svg', 'r'), 'logo', 'image/svg+xml')
        ->attachFromPath('README.md')
    ;

    // Headers
    $email->getHeaders()
        ->addTextHeader('X-Message-Source', '1alf.com')
        ->add(new UnstructuredHeader('X-Mailer', 'Mailtrap PHP Client'))
    ;

    // Benutzerdefinierte Variablen
    $email->getHeaders()
        ->add(new CustomVariableHeader('user_id', '45982'))
        ->add(new CustomVariableHeader('batch_id', 'PSJ-12'))
    ;

    // Kategorie (sollte nur eine sein)
    $email->getHeaders()
        ->add(new CategoryHeader('Integration Test'))
    ;

    // Erforderlicher Parameter -> inbox_id
    $response = $mailtrap->sandbox()->emails()->send($email, 1000001); // <--- Sie sollten hier Ihre inbox_id verwenden (sonst erhalten Sie 401)

    // Alle möglichen Informationen aus der Antwort ausgeben
    var_dump($response->getHeaders()); //headers (array)
    var_dump($response->getStatusCode()); //status code (int)
    var_dump(ResponseHelper::toArray($response)); // body (array)
} catch (Exception $e) {
    echo 'Ausnahme abgefangen: ',  $e->getMessage(), "\n";
}

Und vergessen Sie natürlich nicht, Platzhalterwerte wie das API-Token und andere Anmeldeinformationen durch die tatsächlichen Daten aus Ihrem Mailtrap-Konto zu ersetzen.

Weitere Informationen zur Mailtrap Email Testing API, ihren Funktionalitäten und den verschiedenen Operationen, die Sie damit durchführen können (z. B. Testing und QA-Automatisierung, Testen automatisierter Sequenzen usw.), finden Sie in der offiziellen Dokumentation.

Zusammenfassung

Damit schließen wir unser Tutorial zum Senden von E-Mails in PHP ab!

Ich habe die beliebtesten Optionen für den E-Mail-Versand in PHP durchgesehen und beschrieben, wie Sie dies mit einem Drittanbieter-Mailservice wie Mailtrap tun können, der Ihnen helfen kann, Zeit, Geld und Mühe zu sparen.

Wenn Sie mehr erfahren möchten, schauen Sie sich unbedingt unseren Blog an, wo Sie weitere PHP-bezogene Artikel lesen können, wie z. B.:

Article by Viktoriia Ivanenko Technical Content Writer @ Mailtrap

Experienced content and marketing specialist: content creation for the blog and video channel, UX/UI copies, technical writing, app localizations, and SEO. Skilled in marketing strategies, video production and management, creating brand concepts, technical and marketing writing, and analytical skills. Strong information technology professional of 10+ years work experience with a background from The University of Edinburgh, UK and Clark University, USA.

Ivan Djuric, an author at Mailtrap
Article by Ivan Djuric Technical Content Writer @Mailtrap

I’m a Technical Content Writer with 5 years of background covering email-related topics in tight collaboration with software engineers and email marketers. I just love to research and share actionable insights with you about email sending, testing, deliverability improvements, and more. Happy to be your guide in the world of emails!