Email infrastructure you can stop thinking about

import { Mailkube } from "@mailkube/mailkube-node";

const client = new Mailkube({ apiKey: "mk_<key_id>_<secret>" });

const email = await client.emails.send({
  from: "Acme <hello@yourdomain.com>",
  to: "customer@example.com",
  subject: "Hello world",
  html: "<p>It works!</p>",
});

console.log(email.id);

import { Mailkube } from "@mailkube/mailkube-node";

// The key arrives per request through the env binding,
// so build the client inside the handler.
export default {
  async fetch(request: Request, env: { MAILKUBE_API_KEY: string }) {
    const client = new Mailkube({ apiKey: env.MAILKUBE_API_KEY });
    await client.emails.send({
      from: "Acme <hello@yourdomain.com>",
      to: "customer@example.com",
      subject: "Hello world",
      html: "<p>It works!</p>",
    });
    return new Response(null, { status: 204 });
  },
};

import { Mailkube } from "npm:@mailkube/mailkube-node";

const client = new Mailkube(); // reads MAILKUBE_API_KEY

await client.emails.send({
  from: "Acme <hello@yourdomain.com>",
  to: "customer@example.com",
  subject: "Hello world",
  html: "<p>It works!</p>",
});

// bun add @mailkube/mailkube-node
import { Mailkube } from "@mailkube/mailkube-node";

const client = new Mailkube(); // reads MAILKUBE_API_KEY

await client.emails.send({
  from: "Acme <hello@yourdomain.com>",
  to: "customer@example.com",
  subject: "Hello world",
  html: "<p>It works!</p>",
});

from mailkube import Mailkube

client = Mailkube(api_key="mk_<key_id>_<secret>")

email = client.emails.send(
    from_="Acme <hello@yourdomain.com>",
    to="customer@example.com",
    subject="Hello world",
    html="<p>It works!</p>",
)

print(email.id)

from contextlib import asynccontextmanager

from fastapi import FastAPI
from mailkube import AsyncMailkube


@asynccontextmanager
async def lifespan(app: FastAPI):
    # Created once on startup and reused for every request.
    app.state.mailkube = AsyncMailkube()
    try:
        yield
    finally:
        await app.state.mailkube.aclose()


app = FastAPI(lifespan=lifespan)


@app.post("/emails")
async def send_email(to: str, subject: str, html: str):
    email = await app.state.mailkube.emails.send(
        from_="Acme <hello@yourdomain.com>",
        to=to,
        subject=subject,
        html=html,
    )
    return {"id": email.id, "message_id": email.message_id}

from flask import Flask, jsonify, request
from mailkube import Mailkube

app = Flask(__name__)

# One shared client for the whole process.
# Reads MAILKUBE_API_KEY from the env.
client = Mailkube()


@app.post("/emails")
def send_email():
    payload = request.get_json(force=True)
    email = client.emails.send(
        from_="Acme <hello@yourdomain.com>",
        to=payload["to"],
        subject=payload["subject"],
        html=payload["html"],
    )
    return jsonify({"id": email.id, "message_id": email.message_id})

# pip install mailkube-django
# settings.py
EMAIL_BACKEND = "mailkube_django.backends.EmailBackend"
MAILKUBE_API_KEY = "mk_<key_id>_<secret>"

# anywhere in your app
from django.core.mail import send_mail

send_mail(
    subject="Hello world",
    message="It works!",
    from_email="Acme <hello@yourdomain.com>",
    recipient_list=["customer@example.com"],
)

# pip install "mailkube-django[anymail]"
# settings.py
EMAIL_BACKEND = "mailkube_django.anymail_backend.EmailBackend"
MAILKUBE_API_KEY = "mk_<key_id>_<secret>"

# Anymail's own esp_extra and tags then work as usual.
from django.core.mail import EmailMessage

message = EmailMessage(
    subject="Hello world",
    body="It works!",
    from_email="Acme <hello@yourdomain.com>",
    to=["customer@example.com"],
)
message.send()

package main

import (
    "context"
    "log"

    "github.com/mailkube/mailkube-go"
)

func main() {
    client, err := mailkube.New() // reads MAILKUBE_API_KEY
    if err != nil {
        log.Fatal(err)
    }

    email, err := client.Emails.Send(context.Background(), mailkube.SendEmailParams{
        From:    "Acme <hello@yourdomain.com>",
        To:      []string{"customer@example.com"},
        Subject: "Hello world",
        HTML:    "<p>It works!</p>",
    })
    if err != nil {
        log.Fatal(err)
    }
    log.Println(email.ID, email.MessageID)
}

type Mailer struct {
    client *mailkube.Client
}

func main() {
    client, err := mailkube.New() // reads MAILKUBE_API_KEY
    if err != nil {
        log.Fatal(err)
    }
    mailer := &Mailer{client: client}

    r := gin.Default()
    r.POST("/signup", mailer.signup)
    r.Match([]string{"GET", "POST"}, "/webhooks", gin.WrapH(webhookHandler()))
    log.Fatal(r.Run(":8080"))
}

client, err := mailkube.New() // reads MAILKUBE_API_KEY
if err != nil {
    log.Fatal(err)
}
h := &handler{client: client}

e := echo.New()
e.Use(middleware.Recover())
e.POST("/receipts", h.sendReceipt)
e.Any("/webhooks", echo.WrapHandler(webhookHandler()))
log.Fatal(e.Start(":8080"))

client, err := mailkube.New() // reads MAILKUBE_API_KEY
if err != nil {
    log.Fatal(err)
}

app := fiber.New()
app.Post("/signup", signup(client))
app.All("/webhooks", adaptor.HTTPHandler(webhookHandler()))
log.Fatal(app.Listen(":8080"))

<?php

require 'vendor/autoload.php';

use Mailkube\Client;

$client = new Client(); // reads MAILKUBE_API_KEY

$email = $client->emails->send(
    from: 'Acme <hello@yourdomain.com>',
    to: 'customer@example.com',
    subject: 'Hello world',
    html: '<p>It works!</p>',
);

echo $email->id, ' ', $email->messageId;

// composer require mailkube/mailkube-laravel
//
// config/mail.php
//   'mailers' => ['mailkube' => ['transport' => 'mailkube']],
//
// .env
//   MAIL_MAILER=mailkube
//   MAILKUBE_API_KEY=mk_<key_id>_<secret>

use Illuminate\Support\Facades\Mail;

Mail::to('customer@example.com')->send(new OrderShipped($order));

require "mailkube"

client = Mailkube.new # reads MAILKUBE_API_KEY

email = client.emails.send(
  from: "Acme <hello@yourdomain.com>",
  to: "customer@example.com",
  subject: "Hello world",
  html: "<p>It works!</p>"
)

puts email.id

# Gemfile
gem "mailkube-rails"

# config/environments/production.rb
config.action_mailer.delivery_method = :mailkube
config.action_mailer.mailkube_settings = {
  api_key: ENV.fetch("MAILKUBE_API_KEY")
}

# Every ActionMailer delivery now goes through mailkube.
OrderMailer.with(order: order).shipped.deliver_later

import com.mailkube.MailkubeClient;
import com.mailkube.model.Email;
import com.mailkube.model.SendEmailParams;
import java.util.List;

// reads MAILKUBE_API_KEY
try (MailkubeClient client = MailkubeClient.builder().build()) {
    Email email = client.emails().send(
        SendEmailParams.builder(
                "Acme <hello@yourdomain.com>",
                List.of("customer@example.com"),
                "Hello world")
            .html("<p>It works!</p>")
            .build());

    System.out.println(email.id());
}

// build.gradle.kts
//   implementation("com.mailkube:mailkube-spring-boot:X.Y.Z")
// application.properties
//   mailkube.api-key=mk_<key_id>_<secret>

@Service
class OrderService {

    private final MailSender mail;

    OrderService(MailSender mail) {
        this.mail = mail;
    }

    void confirm(Order order) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom("Acme <hello@yourdomain.com>");
        message.setTo(order.customerEmail());
        message.setSubject("Your order shipped");
        message.setText("It is on its way.");
        mail.send(message);
    }
}

curl -X POST https://api.mailkube.com/mta/v1/emails \
  -H "Authorization: Bearer mk_<key_id>_<secret>" \
  -H "Content-Type: application/json" \
  -d '{
    "from": "Acme <hello@yourdomain.com>",
    "to": "customer@example.com",
    "subject": "Hello world",
    "html": "<p>It works!</p>"
  }'

mailkube emails send \
  --from "Acme <hello@yourdomain.com>" \
  --to customer@example.com \
  --subject "Your invoice" \
  --html "<p>Thanks for your order.</p>"

SMTP_HOST=smtp.mailkube.com
SMTP_PORT=587
SMTP_SECURITY=STARTTLS
SMTP_USERNAME=<your-smtp-credential-username>
SMTP_PASSWORD=<your-smtp-credential-password>