Tutorial

E-Mails mit .NET senden

Senden Sie E-Mails aus ASP.NET Core und .NET mit dem Emailit-NuGet-Paket, MailKit oder System.Net.Mail per SMTP und verifizieren Sie Emailit-Webhooks.

Aktualisiert am 1. Okt. 2026

Diese Anleitung zeigt, wie Sie E-Mails aus einer .NET-App mit dem offiziellen NuGet-Paket Emailit senden, wie Sie stattdessen MailKit oder System.Net.Mail per SMTP verwenden und wie Sie Webhooks in einer Minimal API von ASP.NET Core verifizieren.

Voraussetzungen

.NET 8 oder neuer.
Eine verifizierte Versanddomain, zum Beispiel acme.com.
Ein API-Schlüssel. Ein reiner Sende-Schlüssel, der auf Ihre Domain beschränkt ist, genügt.
Solange Ihr Workspace keinen Produktionszugang hat, können Sie nur an die Konto-E-Mail-Adressen von Workspace-Mitgliedern senden.

SDK installieren

Terminal

dotnet add package Emailit

API-Schlüssel konfigurieren

ASP.NET Core liest die Konfiguration aus Umgebungsvariablen, in denen __ die Abschnitte trennt. Setzen Sie in der Produktion Emailit__ApiKey:

Terminal

export Emailit__ApiKey=secret_••••••••••••••••••••••••••••••••

Bewahren Sie den Schlüssel während der Entwicklung in den User Secrets statt in appsettings.json auf:

Terminal

dotnet user-secrets init
dotnet user-secrets set "Emailit:ApiKey" "secret_••••••••••••••••••••••••••••••••"

E-Mail senden

Registrieren Sie einen Client und injizieren Sie ihn in Ihre Endpunkte:

Program.cs

using Emailit;
using Emailit.Options;
using Emailit.Resources;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddSingleton(new EmailitClient(builder.Configuration["Emailit:ApiKey"]!));

var app = builder.Build();

app.MapPost("/orders/{id}/confirm", (string id, EmailitClient emailit) =>
{
    Email email = emailit.Emails.Send(new EmailSendOptions
    {
        From = "Acme <orders@acme.com>",
        To = new[] { "ada@example.com" },
        Subject = $"Order {id} confirmed",
        Html = $"<p>We've received order {id}.</p>",
    });

    return Results.Ok(new { emailId = email.Id });
});

app.Run();

Send ist synchron; führen Sie Massenversände in einem Hintergrunddienst aus, damit die Request-Threads frei bleiben. Die Optionen akzeptieren außerdem Cc, Bcc, ReplyTo, Attachments, Template mit Variables, ScheduledAt und Tracking; siehe E-Mail senden.

Wenn Ihr Code bereits Objekte vom Typ System.Net.Mail.MailMessage erstellt, kann das SDK sie über die API senden:

using System.Net.Mail;

var message = new MailMessage("orders@acme.com", "ada@example.com", "Order confirmed", "<p>Thanks!</p>")
{
    IsBodyHtml = true,
};

Email email = emailit.Emails.Send(message);

Fehler behandeln

using Emailit.Exceptions;

try
{
    emailit.Emails.Send(options);
}
catch (RateLimitException)
{
    // 429: back off and retry
}
catch (AuthenticationException)
{
    // 401: the API key is missing or invalid
}
catch (UnprocessableEntityException ex)
{
    // 422: for example, the from domain isn't verified
    logger.LogWarning("Emailit rejected the email: {Message}", ex.Message);
}
catch (ApiErrorException ex)
{
    logger.LogError("Emailit error {Status}: {Body}", ex.HttpStatus, ex.HttpBody);
}

Alternativ per SMTP senden

MailKit

Microsoft empfiehlt MailKit für neuen SMTP-Code. Installieren Sie es mit dotnet add package MailKit:

using MailKit.Net.Smtp;
using MailKit.Security;
using MimeKit;

var message = new MimeMessage();
message.From.Add(new MailboxAddress("Acme", "orders@acme.com"));
message.To.Add(MailboxAddress.Parse("ada@example.com"));
message.Subject = "Order confirmed";
message.Body = new TextPart("html") { Text = "<p>We've received your order.</p>" };

using var smtp = new SmtpClient();
await smtp.ConnectAsync("smtp.emailit.com", 587, SecureSocketOptions.StartTls);
await smtp.AuthenticateAsync("emailit", builder.Configuration["Emailit:ApiKey"]);
await smtp.SendAsync(message);
await smtp.DisconnectAsync(true);

Für implizites TLS verbinden Sie sich mit Port 465 und SecureSocketOptions.SslOnConnect.

System.Net.Mail

Der integrierte Client reicht für einfache Fälle. Er unterstützt nur STARTTLS; verwenden Sie daher Port 587 (oder 2525 bzw. 2587):

using System.Net;
using System.Net.Mail;

using var client = new SmtpClient("smtp.emailit.com", 587)
{
    EnableSsl = true,
    Credentials = new NetworkCredential("emailit", apiKey),
};

client.Send(new MailMessage("orders@acme.com", "ada@example.com", "Order confirmed", "We've received your order."));

Alle Ports finden Sie unter SMTP-Einstellungen.

Webhooks empfangen

Erstellen Sie einen Webhook und speichern Sie sein Signatur-Secret als Emailit:WebhookSecret. Lesen Sie den unveränderten Body, verifizieren Sie ihn und parsen Sie dann das Array der Events:

Program.cs

using System.Security.Cryptography;
using System.Text;
using System.Text.Json;

app.MapPost("/webhooks/emailit", async (HttpRequest request, IConfiguration config) =>
{
    using var reader = new StreamReader(request.Body, Encoding.UTF8);
    var body = await reader.ReadToEndAsync();

    var signature = request.Headers["X-Emailit-Signature"].ToString();
    var timestamp = request.Headers["X-Emailit-Timestamp"].ToString();

    if (!long.TryParse(timestamp, out var ts) ||
        Math.Abs(DateTimeOffset.UtcNow.ToUnixTimeSeconds() - ts) > 300)
    {
        return Results.Unauthorized();
    }

    using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(config["Emailit:WebhookSecret"]!));
    var expected = Convert.ToHexString(hmac.ComputeHash(Encoding.UTF8.GetBytes($"{timestamp}.{body}"))).ToLowerInvariant();

    if (!CryptographicOperations.FixedTimeEquals(Encoding.UTF8.GetBytes(expected), Encoding.UTF8.GetBytes(signature)))
    {
        return Results.Unauthorized();
    }

    // The body is a JSON array of up to 100 events.
    using var events = JsonDocument.Parse(body);
    foreach (var evt in events.RootElement.EnumerateArray())
    {
        if (evt.GetProperty("type").GetString() == "email.bounced")
        {
            var address = evt.GetProperty("data").GetProperty("object").GetProperty("to").GetString();
            // Stop emailing this address.
        }
    }

    return Results.Ok();
});

Geben Sie innerhalb von 30 Sekunden einen 2xx-Status zurück; bei anderen Antworten wird die Anfrage wiederholt. Siehe Anfragesignatur.

Tipps für den Produktivbetrieb

Client als Singleton registrieren. Ein EmailitClient pro App genügt.
Massen-E-Mails in eine Warteschlange stellen. Senden Sie aus einem BackgroundService oder mit einer Job-Bibliothek wie Hangfire und drosseln Sie den Versand, um unter Ihren Versandlimits zu bleiben (standardmäßig 2 E-Mails pro Sekunde).
Wiederholungen sicher machen. Wenn Sie nach einem Timeout erneut senden, übergeben Sie mit HttpClient einen Header Idempotency-Key; siehe Idempotenz.
Webhooks deduplizieren, indem Sie jede verarbeitete event_id speichern.

Nächste Schritte

E-Mails per API senden

Anhänge, Planung und Tracking.

Webhook-Event-Typen

Alle Events und ihre Payloads.

SMTP-Fehlerbehebung

Authentifizierungs- und Verbindungsfehler beheben.

SDKs und Bibliotheken

Alle offiziellen Bibliotheken.