Send email from C# and .NET with one HTTP call.

using System.Net.Http.Json;
using System.Text.Json;
using System.Text.Json.Serialization;

public sealed record SendEmailRequest(
    string From,
    string To,
    string Subject,
    string? Html = null,
    string? Text = null,
    string? TemplateId = null,
    Dictionary<string, string>? Variables = null);

public sealed record SendEmailResponse(string EmailId);

public sealed record ApiError(string Code, string Message);

sealed record ErrorEnvelope(ApiError Error);

public sealed class NotixClient(IHttpClientFactory factory)
{
    // The API speaks camelCase; the records above are PascalCase.
    private static readonly JsonSerializerOptions Json = new(JsonSerializerDefaults.Web)
    {
        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
    };

    public async Task<Result<SendEmailResponse, ApiError>> SendAsync(
        SendEmailRequest email, string idempotencyKey, CancellationToken ct = default)
    {
        var http = factory.CreateClient("notix");

        using var request = new HttpRequestMessage(HttpMethod.Post, "emails")
        {
            Content = JsonContent.Create(email, options: Json),
        };
        // One key per business event, so a retry can never send twice.
        request.Headers.Add("Idempotency-Key", idempotencyKey);

        using var response = await http.SendAsync(request, ct);

        if (response.IsSuccessStatusCode)
        {
            var ok = await response.Content.ReadFromJsonAsync<SendEmailResponse>(Json, ct);
            return Result<SendEmailResponse, ApiError>.Ok(ok!);
        }

        // Every refusal is { "error": { "code", "message" } }; a 413 for a body
        // over 20 MB is the one answer with no JSON.
        var envelope = await response.Content.ReadFromJsonAsync<ErrorEnvelope>(Json, ct);
        return Result<SendEmailResponse, ApiError>.Fail(
            envelope?.Error ?? new ApiError("HTTP_" + (int)response.StatusCode, "No error body"));
    }
}

// A small discriminated result so callers must handle the refusal.
// Use OneOf, ErrorOr or LanguageExt if your project already has one.
public readonly struct Result<TOk, TError>
{
    private readonly TOk? _ok;
    private readonly TError? _error;
    public bool IsOk { get; }

    private Result(TOk? ok, TError? error, bool isOk) { _ok = ok; _error = error; IsOk = isOk; }

    public static Result<TOk, TError> Ok(TOk value) => new(value, default, true);
    public static Result<TOk, TError> Fail(TError error) => new(default, error, false);

    public T Match<T>(Func<TOk, T> ok, Func<TError, T> fail) =>
        IsOk ? ok(_ok!) : fail(_error!);
}

curl -X POST https://app.usenotix.dev/api/v1/emails \
  -H "Authorization: Bearer $NOTIX_API_KEY" \
  -H "Idempotency-Key: order-4471-receipt" \
  -H "Content-Type: application/json" \
  -d '{ "from": "receipts@acme.com", "to": "customer@example.com",
        "subject": "Your receipt for order 4471",
        "html": "<p>Thanks for your order.</p>", "text": "Thanks for your order." }'

# 200 { "emailId": "eml_abc123" }
# 400 { "error": { "code": "BAD_REQUEST",   "message": "..." } }   your request
# 401 { "error": { "code": "UNAUTHORIZED",  "message": "..." } }   bad or missing key
# 409 { "error": { "code": "NOT_UNIQUE",    "message": "..." } }   same key, different body
# 429 { "error": { "code": "RATE_LIMITED",  "message": "Rate limit exceeded. Try again in 60 seconds." } }