Send Email in C# via SMTP (MailKit)

Send emails through AhaSend’s SMTP servers using C# and .NET with the powerful MailKit library. This guide covers why you should avoid System.Net.Mail and use MailKit instead for reliable email delivery.

Avoid System.Net.Mail: The built-in SmtpClient in .NET does not reliably support AUTH PLAIN over STARTTLS, causing authentication failures with AhaSend. Use MailKit instead for guaranteed compatibility.

Prerequisites

Before sending, verify your domain and create an SMTP credential. Use a sandbox credential for these examples so no email is delivered. Keep the username and password in your server’s secret store. Before you begin, ensure you have:

Development Environment

.NET SDK installed (.NET 6.0 or higher recommended)
Visual Studio or Visual Studio Code for development
NuGet package manager access
Basic knowledge of C# programming

Project Dependencies

MailKit NuGet package (recommended)
MimeKit (included with MailKit)
Avoid using System.Net.Mail for PLAIN AUTH over STARTTLS

Why MailKit Over System.Net.Mail?

AhaSend works with any SMTP-compatible library, but for C#/.NET applications, we strongly recommend MailKit over the built-in System.Net.Mail:

✅ MailKit (Recommended)

Pros: Modern, reliable STARTTLS
Auth: AUTH PLAIN/LOGIN support
Compatibility: Works with StartTLS
Features: Rich MIME support, attachments, HTML

❌ System.Net.Mail (Avoid)

Issues: Unreliable STARTTLS authentication
Auth: Silent AUTH failures with AhaSend
Status: Legacy, minimal updates
Problems: May not send AUTH commands at all

Connection Settings

Setting	Value
EU host	`send.ahasend.com`
US connection point	`send-us.ahasend.com`; accepts SMTP and forwards it to the EU
Ports	25, 587 and 2525
Encryption	STARTTLS required on every supported port
Authentication	AUTH PLAIN only after STARTTLS
Username and password	Your SMTP credential, not an API key
Port 465	Implicit TLS is not supported

All message data is stored in the EU. See SMTP limits.

Why System.Net.Mail Fails

The built-in System.Net.Mail.SmtpClient in .NET has fundamental issues with STARTTLS authentication that make it incompatible with AhaSend.

The Problem

Even with correct credentials and EnableSsl = true, the SMTP client often never issues an AUTH command after the STARTTLS handshake. This causes silent authentication failures where the connection appears to succeed but emails are rejected.

Tested and Confirmed: We’ve tested this issue on .NET 9 across Linux and Windows. The problem persists across different .NET versions and platforms.

What Doesn’t Work

Here’s the problematic code that fails with AhaSend:

System.Net.Mail (Don't Use This)

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

class Program
{
    static void Main(string[] args)
    {
        SmtpClient smtp = new SmtpClient("send.ahasend.com", 587);

        // Enable StartTLS
        smtp.EnableSsl = true;

        // Don't use the OS/Windows account. We want to supply our own credentials.
        smtp.UseDefaultCredentials = false;
        smtp.Credentials = new NetworkCredential("YOUR_SMTP_USERNAME", "YOUR_SMTP_PASSWORD");

        MailMessage message = new MailMessage("hello@yourdomain.com", "user@example.com");
        message.Subject = "Testing Auth";
        message.Body = "This is a test email via AUTH PLAIN.";

        try
        {
            smtp.Send(message);
            Console.WriteLine("Email sent successfully.");
        }
        catch (Exception ex)
        {
            Console.WriteLine("Error sending email: " + ex.Message);
            if (ex.InnerException != null)
            {
                Console.WriteLine("Inner Exception: " + ex.InnerException.Message);
            }
        }
    }
}

Debugging the Issue

You can confirm this authentication failure by capturing SMTP traffic with tools like tcpdump or Wireshark:

Connection succeeds - Client connects to AhaSend SMTP server
STARTTLS works - TLS encryption is established successfully
AUTH command missing - Client never sends authentication credentials
Silent failure - No clear error message, just rejection

Know a Workaround? If you’ve found a way to make System.Net.Mail work reliably with AhaSend’s AUTH PLAIN over STARTTLS, please contact our support team. We’d be happy to update this guide with your solution!

Use MailKit (Recommended)

MailKit is a modern, actively maintained .NET library that correctly handles SMTP authentication with AhaSend. It properly negotiates authentication mechanisms like PLAIN and LOGIN over STARTTLS.

Installation

Install MailKit via NuGet Package Manager:

Install-Package MailKit

dotnet add package MailKit

Use the exact version installed by dotnet add package MailKit in your project file:

<PackageReference Include="MailKit" Version="YOUR_INSTALLED_VERSION" />

Search for "MailKit" by Jeffrey Stedfast in NuGet Package Manager

MimeKit Included: MailKit automatically includes MimeKit for MIME message construction. No additional packages needed!

Basic MailKit Examples

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

class Program
{
    static void Main()
    {
        using (var client = new SmtpClient())
        {
            try
            {
                // Connect to AhaSend SMTP with STARTTLS
                client.Connect("send.ahasend.com", 587, SecureSocketOptions.StartTls);

                // Authenticate with your SMTP credentials
                client.Authenticate("YOUR_SMTP_USERNAME", "YOUR_SMTP_PASSWORD");

                // Create a simple message
                var message = new MimeMessage();
                message.From.Add(new MailboxAddress("Your Company", "hello@yourdomain.com"));
                message.To.Add(new MailboxAddress("User", "user@example.com"));
                message.Subject = "Welcome to our platform!";
                message.Body = new TextPart("plain")
                {
                    Text = "Thanks for signing up. We're excited to have you!"
                };

                client.Send(message);
                client.Disconnect(true);

                Console.WriteLine("Email sent successfully!");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Failed to send email: {ex.Message}");
            }
        }
    }
}

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

class Program
{
    static void Main()
    {
        using (var client = new SmtpClient())
        {
            try
            {
                // Connect to AhaSend SMTP with STARTTLS
                client.Connect("send.ahasend.com", 587, SecureSocketOptions.StartTls);

                // Authenticate with your SMTP credentials
                client.Authenticate("YOUR_SMTP_USERNAME", "YOUR_SMTP_PASSWORD");

                // Create an HTML message
                var message = new MimeMessage();
                message.From.Add(new MailboxAddress("Your Company", "hello@yourdomain.com"));
                message.To.Add(new MailboxAddress("User", "user@example.com"));
                message.Subject = "Welcome to our platform!";

                var builder = new BodyBuilder();

                // Set the plain-text version of the message text
                builder.TextBody = "Welcome! Thanks for signing up. Visit https://yourdomain.com/get-started to get started.";

                // Set the html version of the message text
                builder.HtmlBody = @"
                    <html>
                    <body>
                        <h1>Welcome!</h1>
                        <p>Thanks for signing up. We're <strong>excited</strong> to have you!</p>
                        <p><a href=""https://yourdomain.com/get-started"">Get Started</a></p>
                    </body>
                    </html>";

                message.Body = builder.ToMessageBody();

                client.Send(message);
                client.Disconnect(true);

                Console.WriteLine("HTML email sent successfully!");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Failed to send email: {ex.Message}");
            }
        }
    }
}

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

class Program
{
    static void Main()
    {
        using (var client = new SmtpClient())
        {
            try
            {
                // Connect to AhaSend SMTP with STARTTLS
                client.Connect("send.ahasend.com", 587, SecureSocketOptions.StartTls);

                // Authenticate with your SMTP credentials
                client.Authenticate("YOUR_SMTP_USERNAME", "YOUR_SMTP_PASSWORD");

                // Create message with attachment
                var message = new MimeMessage();
                message.From.Add(new MailboxAddress("Your Company", "hello@yourdomain.com"));
                message.To.Add(new MailboxAddress("User", "user@example.com"));
                message.Subject = "Your Invoice is Ready";

                var builder = new BodyBuilder();

                // Set the message body
                builder.TextBody = "Please find your invoice attached to this email.";
                builder.HtmlBody = @"
                    <html>
                    <body>
                        <h1>Invoice Attached</h1>
                        <p>Please find your invoice attached to this email.</p>
                    </body>
                    </html>";

                // Add attachment
                string attachmentPath = @"C:\path\to\invoice.pdf";
                if (File.Exists(attachmentPath))
                {
                    builder.Attachments.Add(attachmentPath);
                }

                message.Body = builder.ToMessageBody();

                client.Send(message);
                client.Disconnect(true);

                Console.WriteLine("Email with attachment sent successfully!");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Failed to send email: {ex.Message}");
            }
        }
    }
}

Advanced MailKit Examples

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

class Program
{
    static void Main()
    {
        using (var client = new SmtpClient())
        {
            try
            {
                // Connect to AhaSend SMTP with STARTTLS
                client.Connect("send.ahasend.com", 587, SecureSocketOptions.StartTls);

                // Authenticate with your SMTP credentials
                client.Authenticate("YOUR_SMTP_USERNAME", "YOUR_SMTP_PASSWORD");

                // Create message with multiple recipients
                var message = new MimeMessage();
                message.From.Add(new MailboxAddress("Your Company", "updates@yourdomain.com"));

                // Add multiple recipients
                message.To.Add(new MailboxAddress("User One", "user1@example.com"));
                message.To.Add(new MailboxAddress("User Two", "user2@example.com"));

                // Add CC recipient
                message.Cc.Add(new MailboxAddress("Manager", "manager@yourdomain.com"));

                // Add BCC recipient (not visible to other recipients)
                message.Bcc.Add(new MailboxAddress("Analytics", "analytics@yourdomain.com"));

                message.Subject = "Product Updates with Tracking";

                // Add AhaSend special headers
                message.Headers.Add("ahasend-track-opens", "true");
                message.Headers.Add("ahasend-track-clicks", "true");
                message.Headers.Add("ahasend-tags", "product-update,newsletter,csharp");
                message.Headers.Add("AhaSend-Metadata-Retention", "30");
                message.Headers.Add("AhaSend-Data-Retention", "7");

                var builder = new BodyBuilder();
                builder.TextBody = "Check out our latest features at https://yourdomain.com/features";
                builder.HtmlBody = @"
                    <html>
                    <body>
                        <h1>Product Updates</h1>
                        <p>Check out our <a href=""https://yourdomain.com/features"">latest features</a>!</p>
                        <p>This email has tracking enabled and custom tags.</p>
                    </body>
                    </html>";

                message.Body = builder.ToMessageBody();

                client.Send(message);
                client.Disconnect(true);

                Console.WriteLine("Email sent with special headers!");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Failed to send email: {ex.Message}");
            }
        }
    }
}

using System;
using System.Collections.Generic;
using MailKit.Net.Smtp;
using MailKit.Security;
using MimeKit;

class Program
{
    static void Main()
    {
        // Recipients list
        var recipients = new List<(string Email, string Name)>
        {
            ("user1@example.com", "John Doe"),
            ("user2@example.com", "Jane Smith"),
            ("user3@example.com", "Bob Johnson")
        };

        using (var client = new SmtpClient())
        {
            try
            {
                // Connect once for all emails
                client.Connect("send.ahasend.com", 587, SecureSocketOptions.StartTls);
                client.Authenticate("YOUR_SMTP_USERNAME", "YOUR_SMTP_PASSWORD");

                foreach (var recipient in recipients)
                {
                    try
                    {
                        var message = new MimeMessage();
                        message.From.Add(new MailboxAddress("Your Company", "hello@yourdomain.com"));
                        message.To.Add(new MailboxAddress(recipient.Name, recipient.Email));
                        message.Subject = "Personalized Newsletter";

                        // Add custom header for bulk emails
                        message.Headers.Add("ahasend-tags", "newsletter,bulk,csharp");

                        var builder = new BodyBuilder();
                        builder.TextBody = $"Hello {recipient.Name}! This is your personalized newsletter.";
                        builder.HtmlBody = $@"
                            <html>
                            <body>
                                <h1>Hello {recipient.Name}!</h1>
                                <p>This is your personalized newsletter.</p>
                            </body>
                            </html>";

                        message.Body = builder.ToMessageBody();

                        client.Send(message);
                        Console.WriteLine($"Email sent to {recipient.Email}");

                        // Add delay to avoid rate limiting
                        System.Threading.Thread.Sleep(100);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"Failed to send to {recipient.Email}: {ex.Message}");
                    }
                }

                client.Disconnect(true);
                Console.WriteLine("Bulk email sending completed!");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Failed to connect to SMTP server: {ex.Message}");
            }
        }
    }
}

using System;
using System.Threading.Tasks;
using MailKit.Net.Smtp;
using MailKit.Security;
using MimeKit;

public class EmailService
{
    private readonly string _smtpHost;
    private readonly int _smtpPort;
    private readonly string _smtpUsername;
    private readonly string _smtpPassword;

    public EmailService(string smtpHost, int smtpPort, string smtpUsername, string smtpPassword)
    {
        _smtpHost = smtpHost;
        _smtpPort = smtpPort;
        _smtpUsername = smtpUsername;
        _smtpPassword = smtpPassword;
    }

    public async Task<bool> SendEmailAsync(string fromEmail, string fromName, string toEmail, string toName,
                                          string subject, string textBody, string htmlBody = null)
    {
        try
        {
            using var client = new SmtpClient();

            // Connect to AhaSend SMTP with STARTTLS
            await client.ConnectAsync(_smtpHost, _smtpPort, SecureSocketOptions.StartTls);

            // Authenticate with your SMTP credentials
            await client.AuthenticateAsync(_smtpUsername, _smtpPassword);

            // Create message
            var message = new MimeMessage();
            message.From.Add(new MailboxAddress(fromName, fromEmail));
            message.To.Add(new MailboxAddress(toName, toEmail));
            message.Subject = subject;

            var builder = new BodyBuilder();
            builder.TextBody = textBody;

            if (!string.IsNullOrEmpty(htmlBody))
            {
                builder.HtmlBody = htmlBody;
            }

            message.Body = builder.ToMessageBody();

            await client.SendAsync(message);
            await client.DisconnectAsync(true);

            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Failed to send email: {ex.Message}");
            return false;
        }
    }

    public async Task<bool> SendWelcomeEmailAsync(string toEmail, string toName)
    {
        var subject = "Welcome to our platform!";
        var textBody = $"Hello {toName}, welcome to our platform!";
        var htmlBody = $@"
            <html>
            <body>
                <h1>Welcome {toName}!</h1>
                <p>Thanks for joining our platform. We're excited to have you!</p>
            </body>
            </html>";

        return await SendEmailAsync("hello@yourdomain.com", "Your Company",
                                   toEmail, toName, subject, textBody, htmlBody);
    }
}

// Usage example
class Program
{
    static async Task Main(string[] args)
    {
        var emailService = new EmailService(
            "send.ahasend.com",
            587,
            "YOUR_SMTP_USERNAME",
            "YOUR_SMTP_PASSWORD"
        );

        // Send welcome email
        bool success = await emailService.SendWelcomeEmailAsync("user@example.com", "John Doe");

        if (success)
        {
            Console.WriteLine("Welcome email sent successfully!");
        }
        else
        {
            Console.WriteLine("Failed to send welcome email.");
        }
    }
}

Testing with Sandbox Mode

Use sandbox mode to safely test your C# email integration:

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

class Program
{
    static void Main()
    {
        using (var client = new SmtpClient())
        {
            try
            {
                // Connect to AhaSend SMTP with STARTTLS
                client.Connect("send.ahasend.com", 587, SecureSocketOptions.StartTls);

                // Authenticate with your SMTP credentials
                client.Authenticate("YOUR_SMTP_USERNAME", "YOUR_SMTP_PASSWORD");

                // Create sandbox test message
                var message = new MimeMessage();
                message.From.Add(new MailboxAddress("Test", "test@yourdomain.com"));
                message.To.Add(new MailboxAddress("Test User", "test@example.com"));
                message.Subject = "Sandbox Test Email";

                // Enable sandbox mode
                message.Headers.Add("AhaSend-Sandbox", "true");
                message.Headers.Add("AhaSend-Sandbox-Result", "deliver");

                message.Body = new TextPart("plain")
                {
                    Text = "This email is sent in sandbox mode for testing."
                };

                client.Send(message);
                client.Disconnect(true);

                Console.WriteLine("Sandbox email sent successfully!");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Failed to send sandbox email: {ex.Message}");
            }
        }
    }
}

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

class Program
{
    static void Main()
    {
        using (var client = new SmtpClient())
        {
            try
            {
                // Connect to AhaSend SMTP with STARTTLS
                client.Connect("send.ahasend.com", 587, SecureSocketOptions.StartTls);

                // Authenticate with your SMTP credentials
                client.Authenticate("YOUR_SMTP_USERNAME", "YOUR_SMTP_PASSWORD");

                // Create sandbox bounce test message
                var message = new MimeMessage();
                message.From.Add(new MailboxAddress("Test", "test@yourdomain.com"));
                message.To.Add(new MailboxAddress("Test User", "test@example.com"));
                message.Subject = "Sandbox Bounce Test";

                // Enable sandbox mode with bounce simulation
                message.Headers.Add("AhaSend-Sandbox", "true");
                message.Headers.Add("AhaSend-Sandbox-Result", "bounce");

                var builder = new BodyBuilder();
                builder.TextBody = "This email simulates a bounce for webhook testing.";
                builder.HtmlBody = @"
                    <html>
                    <body>
                        <h1>Bounce Test</h1>
                        <p>This email simulates a bounce for webhook testing.</p>
                    </body>
                    </html>";

                message.Body = builder.ToMessageBody();

                client.Send(message);
                client.Disconnect(true);

                Console.WriteLine("Sandbox bounce test sent - check webhooks!");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Failed to send sandbox email: {ex.Message}");
            }
        }
    }
}

Sandbox Benefits: Emails sent in sandbox mode are free, trigger webhooks normally, and never actually deliver to recipients - perfect for development and testing.

Resources

MailKit Documentation

Official MailKit and MimeKit documentation

Microsoft .NET Docs

Comprehensive .NET development guide

MailKit GitHub

Source code, examples, and issue tracking

AhaSend Support

Get help from our engineering team

Pro Tip: Always use MailKit instead of System.Net.Mail for AhaSend integration. Configure your SMTP settings through dependency injection, implement proper error handling with retry logic, and start with sandbox mode during development. Use async patterns for better performance in web applications.

Before sending: verify your domain and create an SMTP credential.
Connection and message rules: SMTP hosts, ports and limits, special headers, sandbox mode, retention and plan features.
Other ways to send: REST API, AhaSend CLI, Node.js SDK and Go SDK.
Delivery events: webhook setup and local webhook testing.

Getting Started

Domain Authentication

Delivery and Troubleshooting

Sending with SMTP

Sending with the API

Email Tracking

Integrations

Data Retention

Security

Scaling up

Send Email in C# via SMTP (MailKit)

Prerequisites

Why MailKit Over System.Net.Mail?

✅ MailKit (Recommended)

❌ System.Net.Mail (Avoid)

Connection Settings

Why System.Net.Mail Fails

The Problem

What Doesn’t Work

Debugging the Issue

Use MailKit (Recommended)

Installation

Basic MailKit Examples

Advanced MailKit Examples

Testing with Sandbox Mode

Resources

MailKit Documentation

Microsoft .NET Docs

MailKit GitHub

AhaSend Support

​Prerequisites

​Why MailKit Over System.Net.Mail?

✅ MailKit (Recommended)

❌ System.Net.Mail (Avoid)

​Connection Settings

​Why System.Net.Mail Fails

​The Problem

​What Doesn’t Work

​Debugging the Issue

​Use MailKit (Recommended)

​Installation

​Basic MailKit Examples

​Advanced MailKit Examples

​Testing with Sandbox Mode

​Resources

MailKit Documentation

Microsoft .NET Docs

MailKit GitHub

AhaSend Support

​Related Guides

Prerequisites

Why MailKit Over System.Net.Mail?

Connection Settings

Why System.Net.Mail Fails

The Problem

What Doesn’t Work

Debugging the Issue

Use MailKit (Recommended)

Installation

Basic MailKit Examples

Advanced MailKit Examples

Testing with Sandbox Mode

Resources

Related Guides