C# SDK

// Create tracking settings
var tracking = new TrackingSettings(opens: true, clicks: true, unsubscribes: true);

var email = new Email.Builder()
    .From(new Address("sender@example.com", "Your Name"))
    .To(new Address("recipient@example.com", "Recipient Name"))
    .Subject("HTML Email with Tracking")
    .HtmlContent("<h1>Welcome!</h1><p>This is an <strong>HTML email</strong> with tracking enabled.</p>")
    .TextContent("Welcome! This is an HTML email with tracking enabled.")
    .Tracking(tracking)
    .Tag("welcome-email")
    .Build();

var response = await client.SendEmailAsync(email);

var email = new Email.Builder()
    .From(new Address("sender@example.com"))
    .To(new Address("user@example.com"))
    .TemplateId("welcome-template")
    .TemplateData(new Dictionary<string, object>
    {
        ["name"] = "John Doe",
        ["company"] = "Acme Corporation",
        ["activation_link"] = "https://example.com/activate"
    })
    .Build();

var response = await client.SendEmailAsync(email);

// Create attachment from file
var attachment = Attachment.FromFile("/path/to/document.pdf");

var email = new Email.Builder()
    .From(new Address("sender@example.com"))
    .To(new Address("user@example.com"))
    .Subject("Document Attached")
    .TextContent("Please find the document attached.")
    .Attachment(attachment)
    .Build();

var response = await client.SendEmailAsync(email);

var email = new Email.Builder()
    .From(new Address("sender@example.com", "Your Name"))
    .To(new Address("user1@example.com", "User One"))
    .To(new Address("user2@example.com", "User Two"))
    .Cc(new Address("cc@example.com", "CC Recipient"))
    .Bcc(new Address("bcc@example.com", "BCC Recipient"))
    .ReplyTo(new Address("reply@example.com", "Reply To"))
    .Subject("Email to Multiple Recipients")
    .TextContent("This email is being sent to multiple recipients.")
    .Build();

var response = await client.SendEmailAsync(email);

// Schedule for 24 hours from now
var sendTime = DateTimeOffset.UtcNow.AddHours(24).ToUnixTimeSeconds();

var email = new Email.Builder()
    .From(new Address("sender@example.com"))
    .To(new Address("user@example.com"))
    .Subject("Scheduled Email")
    .TextContent("This email was scheduled.")
    .SendTime(sendTime)
    .Build();

var response = await client.SendEmailAsync(email);

var emails = new[]
{
    new Email.Builder()
        .From(new Address("sender@example.com"))
        .To(new Address("user1@example.com"))
        .Subject("Email 1")
        .TextContent("First email content.")
        .Build(),
    new Email.Builder()
        .From(new Address("sender@example.com"))
        .To(new Address("user2@example.com"))
        .Subject("Email 2")
        .TextContent("Second email content.")
        .Build()
};

var response = await client.SendEmailsAsync(emails);

using Microsoft.AspNetCore.Mvc;
using Laneful.Webhooks;

[ApiController]
[Route("api/[controller]")]
public class WebhookController : ControllerBase
{
    private readonly string _webhookSecret;
    private readonly ILogger<WebhookController> _logger;

    public WebhookController(ILogger<WebhookController> logger)
    {
        _logger = logger;
        _webhookSecret = Environment.GetEnvironmentVariable("LANEFUL_WEBHOOK_SECRET") 
            ?? throw new InvalidOperationException("LANEFUL_WEBHOOK_SECRET is required");
    }

    [HttpPost("laneful")]
    public async Task<IActionResult> HandleWebhook()
    {
        try
        {
            // Read raw payload
            using var reader = new StreamReader(Request.Body);
            var payload = await reader.ReadToEndAsync();
            
            if (string.IsNullOrWhiteSpace(payload))
            {
                return BadRequest(new { error = "Empty payload received" });
            }

            // Convert headers to dictionary
            var headers = Request.Headers.ToDictionary(
                h => h.Key,
                h => h.Value.ToString(),
                StringComparer.OrdinalIgnoreCase
            );

            // Extract signature from headers
            var signature = WebhookVerifier.ExtractSignatureFromHeaders(headers);
            if (string.IsNullOrEmpty(signature))
            {
                return Unauthorized(new { error = "Missing signature" });
            }

            // Verify signature
            if (!WebhookVerifier.VerifySignature(_webhookSecret, payload, signature))
            {
                return Unauthorized(new { error = "Invalid signature" });
            }

            // Parse and validate payload
            var webhookData = WebhookVerifier.ParseWebhookPayload(payload);

            // Process events
            foreach (var eventData in webhookData.Events)
            {
                var eventType = eventData["event"]?.ToString();
                var email = eventData["email"]?.ToString();

                switch (eventType)
                {
                    case "delivery":
                        _logger.LogInformation("Email delivered to: {Email}", email);
                        break;
                    case "open":
                        _logger.LogInformation("Email opened by: {Email}", email);
                        break;
                    case "click":
                        var url = eventData["url"]?.ToString() ?? "Unknown URL";
                        _logger.LogInformation("Link clicked by {Email}: {Url}", email, url);
                        break;
                    case "bounce":
                        var isHard = eventData["is_hard"] as bool? ?? false;
                        _logger.LogInformation("Email bounced ({Type}) for: {Email}", 
                            isHard ? "hard" : "soft", email);
                        break;
                }
            }

            return Ok(new
            {
                status = "success",
                processed = webhookData.Events.Count,
                mode = webhookData.IsBatch ? "batch" : "single"
            });
        }
        catch (ArgumentException ex)
        {
            return BadRequest(new { error = $"Invalid payload: {ex.Message}" });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error processing webhook");
            return StatusCode(500, new { error = "Processing error" });
        }
    }
}

using Laneful.Webhooks;

// In your webhook handler
var payload = await request.Body.ReadAsStringAsync(); // Get the raw request body
var signature = request.Headers["x-webhook-signature"].FirstOrDefault();
var secret = "your-webhook-secret";

if (WebhookVerifier.VerifySignature(secret, payload, signature))
{
    // Process webhook data
    var webhookData = WebhookVerifier.ParseWebhookPayload(payload);
    // Handle webhook events
}
else
{
    // Invalid signature
    return BadRequest();
}

// Complete webhook verification and processing workflow
try
{
    // Step 1: Get raw payload
    var payload = await request.Body.ReadAsStringAsync();
    
    // Step 2: Extract signature from headers (supports multiple formats)
    var headers = request.Headers.ToDictionary(
        h => h.Key,
        h => h.Value.ToString(),
        StringComparer.OrdinalIgnoreCase
    );
    var signature = WebhookVerifier.ExtractSignatureFromHeaders(headers);
    
    // Step 3: Verify signature (supports sha256= prefix)
    if (string.IsNullOrEmpty(signature) || 
        !WebhookVerifier.VerifySignature(webhookSecret, payload, signature))
    {
        throw new SecurityException("Invalid webhook signature");
    }
    
    // Step 4: Parse and validate payload structure
    var webhookData = WebhookVerifier.ParseWebhookPayload(payload);
    
    // Step 5: Process events (handles both batch and single event formats)
    foreach (var eventData in webhookData.Events)
    {
        var eventType = eventData["event"]?.ToString();
        var email = eventData["email"]?.ToString();
        
        switch (eventType)
        {
            case "delivery":
                HandleDeliveryEvent(eventData);
                break;
            case "open":
                HandleOpenEvent(eventData);
                break;
            case "click":
                HandleClickEvent(eventData);
                break;
            case "bounce":
                HandleBounceEvent(eventData);
                break;
            case "drop":
                HandleDropEvent(eventData);
                break;
            case "spam_complaint":
                HandleSpamComplaintEvent(eventData);
                break;
            case "unsubscribe":
                HandleUnsubscribeEvent(eventData);
                break;
        }
    }
    
}
catch (ArgumentException ex)
{
    // Payload validation error
    return BadRequest(new { error = $"Invalid payload: {ex.Message}" });
}
catch (Exception ex)
{
    // Other errors
    return Unauthorized(new { error = ex.Message });
}

var webhookData = WebhookVerifier.ParseWebhookPayload(payload);

if (webhookData.IsBatch)
{
    // Processing multiple events in batch mode
    Console.WriteLine($"Processing {webhookData.Events.Count} events in batch");
}
else
{
    // Processing single event
    Console.WriteLine("Processing single event");
}

// Process all events
foreach (var eventData in webhookData.Events)
{
    ProcessEvent(eventData);
}