Webhook delivery & reliability

import express from "express";
import { MailKite } from "mailkite";

const SECRET = process.env.MAILKITE_WEBHOOK_SECRET;
const app = express();
app.use("/hooks/mailkite", express.raw({ type: "application/json" }));

app.post("/hooks/mailkite", (req, res) => {
  if (!MailKite.verifyWebhook(req.headers["x-mailkite-signature"], req.body, SECRET)) {
    return res.sendStatus(401);
  }
  const event = JSON.parse(req.body.toString("utf8"));
  res.type("application/json");

  if (isObviousSpam(event)) {
    // Mark stored as spam — or block the sender for good:
    return res.send(MailKite.replyBlockSender()); // {"status":"ok","actions":[{"type":"block-sender"}]}
  }
  // ...process the message normally
  res.send(MailKite.replyOk());
});

import os
from flask import Flask, request, abort
from mailkite import verify_webhook, reply_ok, reply_spam, reply_block_sender

SECRET = os.environ["MAILKITE_WEBHOOK_SECRET"]
app = Flask(__name__)

@app.post("/hooks/mailkite")
def hook():
    sig = request.headers.get("x-mailkite-signature", "")
    if not verify_webhook(sig, request.get_data(), SECRET):
        abort(401)
    event = request.get_json()
    headers = {"content-type": "application/json"}

    if is_obvious_spam(event):
        # Mark stored as spam, or block the sender for good:
        return reply_block_sender(), 200, headers
    # ...process the message normally
    return reply_ok(), 200, headers

<?php
$mk = new \MailKite\Client("");
$secret = getenv("MAILKITE_WEBHOOK_SECRET");
$signature = $_SERVER["HTTP_X_MAILKITE_SIGNATURE"] ?? "";
$rawBody = file_get_contents("php://input");

if (!$mk->verifyWebhook($signature, $rawBody, $secret)) {
    http_response_code(401);
    exit;
}
$event = json_decode($rawBody, true);
header("content-type: application/json");

if (is_obvious_spam($event)) {
    echo $mk->replySpam(); // {"status":"spam"}  (or $mk->replyBlockSender())
    exit;
}
// ...process the message normally
echo $mk->replyOk();

// Spring Boot
@PostMapping(value = "/hooks/mailkite", produces = "application/json")
public ResponseEntity<String> mailkite(
        @RequestHeader("x-mailkite-signature") String signature,
        @RequestBody byte[] rawBody) throws Exception {
    MailKite mk = new MailKite("");
    String body = new String(rawBody, StandardCharsets.UTF_8);
    if (!mk.verifyWebhook(signature, body, System.getenv("MAILKITE_WEBHOOK_SECRET"))) {
        return ResponseEntity.status(401).build();
    }
    Map<String, Object> event = new ObjectMapper().readValue(body, new TypeReference<>() {});
    if (isObviousSpam(event)) {
        // Mark stored as spam, or block the sender for good:
        return ResponseEntity.ok(mk.replyBlockSender());
    }
    // ...process the message normally
    return ResponseEntity.ok(mk.replyOk());
}

http.HandleFunc("/hooks/mailkite", func(w http.ResponseWriter, r *http.Request) {
	rawBody, _ := io.ReadAll(r.Body)
	sig := r.Header.Get("x-mailkite-signature")
	if !mailkite.VerifyWebhook(sig, string(rawBody), secret) {
		w.WriteHeader(http.StatusUnauthorized)
		return
	}
	var event map[string]any
	json.Unmarshal(rawBody, &event)
	w.Header().Set("content-type", "application/json")

	if isObviousSpam(event) {
		// Mark stored as spam, or block the sender for good:
		w.Write([]byte(mailkite.ReplyBlockSender()))
		return
	}
	// ...process the message normally
	w.Write([]byte(mailkite.ReplyOk()))
})

require "sinatra"
require "json"
require "mailkite"

post "/hooks/mailkite" do
  raw_body = request.body.read
  sig = request.env["HTTP_X_MAILKITE_SIGNATURE"]
  halt 401 unless Mailkite.verify_webhook(sig, raw_body, ENV["MAILKITE_WEBHOOK_SECRET"])
  event = JSON.parse(raw_body)
  content_type :json

  if obvious_spam?(event)
    # Mark stored as spam, or block the sender for good:
    next Mailkite.reply_block_sender
  end
  # ...process the message normally
  Mailkite.reply_ok
end

await mk.retryDelivery("dlv_…");

mk.retryDelivery("dlv_…")

$mk->retryDelivery('dlv_…');

mk.retryDelivery("dlv_…");

_, err := mk.RetryDelivery("dlv_…")

mk.retryDelivery("dlv_…")

curl -X POST https://api.mailkite.dev/api/deliveries/dlv_…/retry \
  -H "Authorization: Bearer <session-token>"