Examples

await notifkit.notify({
  user: "usr_9142",
  template: "order-confirmed",
  channels: ["email"],
  data: { orderId: "99214", total: "$349.00", eta: "Friday" },
});

curl -X POST https://notify.example.com/v1/notify \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "user": "usr_9142",
    "template": "order-confirmed",
    "channels": ["email"],
    "data": { "orderId": "99214", "total": "$349.00", "eta": "Friday" }
  }'

await notifkit.notify({
  user: "usr_9142",
  template: "login-code",
  channels: ["sms", "email"],
  fallback: true,          // try SMS; only if it fails, email
  priority: "critical",    // ignore quiet hours and throttling
  data: { code: "480913", expiresMinutes: 5 },
});

curl -X POST https://notify.example.com/v1/notify \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "user": "usr_9142",
    "template": "login-code",
    "channels": ["sms", "email"],
    "fallback": true,
    "priority": "critical",
    "data": { "code": "480913", "expiresMinutes": 5 }
  }'

await notifkit.notify({
  user: "usr_9142",
  template: "package-shipped",
  channels: ["email", "push"],     // no fallback: send both
  data: { orderId: "99214", carrier: "UPS", tracking: "1Z999AA10123456784", eta: "Friday" },
});

curl -X POST https://notify.example.com/v1/notify \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "user": "usr_9142",
    "template": "package-shipped",
    "channels": ["email", "push"],
    "data": {
      "orderId": "99214",
      "carrier": "UPS",
      "tracking": "1Z999AA10123456784",
      "eta": "Friday"
    }
  }'

// a template with no `topic` is transactional: it cannot be opted out of,
// and it carries no unsubscribe header.
await notifkit.syncTemplates({
  templates: [
    {
      id: "deposit-received",
      channel: "push",
      content: { title: "Money in", text: "{{amount}} from {{sender}} just landed." },
    },
  ],
});

await notifkit.notify({
  user: "usr_9142",
  template: "deposit-received",
  channels: ["push", "email"],
  data: { amount: "$1,250.00", sender: "Stripe Payouts", balance: "$4,318.22" },
});

# a template with no "topic" is transactional: it cannot be opted out of,
# and it carries no unsubscribe header.
curl -X PUT https://notify.example.com/v1/templates \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "templates": [{
      "id": "deposit-received",
      "channel": "push",
      "content": { "title": "Money in", "text": "{{amount}} from {{sender}} just landed." }
    }]
  }'

curl -X POST https://notify.example.com/v1/notify \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "user": "usr_9142",
    "template": "deposit-received",
    "channels": ["push", "email"],
    "data": { "amount": "$1,250.00", "sender": "Stripe Payouts", "balance": "$4,318.22" }
  }'

// the template declares what kind of message it is
await notifkit.syncTemplates({
  templates: [
    {
      id: "new-follower",
      channel: "push",
      topic: "social",                                  // refusable
      content: { title: "New follower", text: "{{name}} started following you." },
    },
  ],
});

await notifkit.notify({
  user: followedUserId,
  template: "new-follower",
  channels: ["push"],
  priority: "low",
  data: { name: "Maya", handle: "@maya", avatar: follower.avatarUrl },
});

// and when they switch it off in your settings screen
await notifkit.updateUserPreferences("usr_9142", { topics: { social: false } });

# the template declares what kind of message it is
curl -X PUT https://notify.example.com/v1/templates \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "templates": [{
      "id": "new-follower",
      "channel": "push",
      "topic": "social",
      "content": { "title": "New follower", "text": "{{name}} started following you." }
    }]
  }'

curl -X POST https://notify.example.com/v1/notify \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "user": "usr_8801",
    "template": "new-follower",
    "channels": ["push"],
    "priority": "low",
    "data": { "name": "Maya", "handle": "@maya" }
  }'

# and when they switch it off in your settings screen
curl -X PATCH https://notify.example.com/v1/users/usr_9142/preferences \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "topics": { "social": false } }'

await notifkit.notify({
  user: "usr_9142",
  template: "driver-arriving",
  channels: ["push", "sms"],
  fallback: true,
  priority: "high",
  data: { driver: "Marcus", etaMinutes: 2, trackUrl: "https://app.co/t/99214" },
});

curl -X POST https://notify.example.com/v1/notify \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "user": "usr_9142",
    "template": "driver-arriving",
    "channels": ["push", "sms"],
    "fallback": true,
    "priority": "high",
    "data": { "driver": "Marcus", "etaMinutes": 2, "trackUrl": "https://app.co/t/99214" }
  }'

await notifkit.notify({
  user: parentComment.authorId,          // the person being replied to
  template: "comment-reply",             // template declares topic: "social"
  channels: ["push"],
  priority: "low",
  data: {
    replier: reply.author.handle,
    excerpt: reply.body.slice(0, 120),
    url: reply.url,
  },
});

curl -X POST https://notify.example.com/v1/notify \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "user": "usr_8801",
    "template": "comment-reply",
    "channels": ["push"],
    "priority": "low",
    "data": {
      "replier": "@alex",
      "excerpt": "This is fire",
      "url": "https://app.co/c/91"
    }
  }'

// when someone taps "notify me when the price drops"
await notifkit.updateUserPreferences("usr_9142", {
  topics: { "price-drop:product-123": true },
});

// when the price actually moves, address the topic instead of a person
await notifkit.notify({
  topic: "price-drop:product-123",
  template: "price-drop",
  channels: ["push", "email"],
  data: { name: "Sony WH-1000XM5", was: "$249.00", now: "$199.00" },
});

# when someone taps "notify me when the price drops"
curl -X PATCH https://notify.example.com/v1/users/usr_9142/preferences \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "topics": { "price-drop:product-123": true } }'

# when the price actually moves, address the topic instead of a person
curl -X POST https://notify.example.com/v1/notify \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "topic": "price-drop:product-123",
    "template": "price-drop",
    "channels": ["push", "email"],
    "data": { "name": "Sony WH-1000XM5", "was": "$249.00", "now": "$199.00" }
  }'

await notifkit.notify({
  user: "usr_9142",
  template: "meeting-reminder",
  channels: ["push"],
  sendAt: "2026-09-12T16:45:00Z",        // absolute UTC, 15 min before a 17:00 meeting
  data: { with: "John", startsIn: 15, joinUrl: "https://meet.co/abc-defg" },
});

// they cancelled the meeting. find the parked task and drop it.
const { scheduled } = await notifkit.getScheduledMessages();
await notifkit.cancelNotification(scheduled[0].taskId);

curl -X POST https://notify.example.com/v1/notify \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "user": "usr_9142",
    "template": "meeting-reminder",
    "channels": ["push"],
    "sendAt": "2026-09-12T16:45:00Z",
    "data": { "with": "John", "startsIn": 15, "joinUrl": "https://meet.co/abc-defg" }
  }'

# they cancelled the meeting. find the parked task and drop it.
curl -s https://notify.example.com/v1/notifications/scheduled \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY"

curl -X DELETE https://notify.example.com/v1/notifications/{taskId} \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY"

// the SDK takes no idempotency argument, so set the header yourself
await fetch("https://notify.example.com/v1/notify", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.NOTIFKIT_API_KEY}`,
    "Content-Type": "application/json",
    "X-Idempotency-Key": "streak-2026-09-07-18",   // the hour this run covers
  },
  body: JSON.stringify({
    segment: "streak-at-risk",
    template: "streak-reminder",
    channels: ["push"],
    priority: "low",
  }),
});

# your own cron, hourly
curl -X POST https://notify.example.com/v1/notify \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "X-Idempotency-Key: streak-2026-09-07-18" \
  -H "Content-Type: application/json" \
  -d '{
    "segment": "streak-at-risk",
    "template": "streak-reminder",
    "channels": ["push"],
    "priority": "low"
  }'

await notifkit.notify({
  user: "usr_9142",
  template: "card-charged",
  channels: ["push", "sms"],       // deliberately NO fallback: send both
  priority: "critical",
  data: {
    amount: "$2,450.00",
    merchant: "ZARA",
    city: "Chicago, IL",
    disputeUrl: "https://bank.co/dispute/tx_5512",
  },
});

curl -X POST https://notify.example.com/v1/notify \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "user": "usr_9142",
    "template": "card-charged",
    "channels": ["push", "sms"],
    "priority": "critical",
    "data": {
      "amount": "$2,450.00",
      "merchant": "ZARA",
      "city": "Chicago, IL",
      "disputeUrl": "https://bank.co/dispute/tx_5512"
    }
  }'

await notifkit.notify({
  user: "usr_9142",
  template: "flight-delayed",
  channels: ["push", "sms", "email"],   // all three, no fallback
  priority: "critical",
  data: {
    flight: "UA 2043",
    destination: "Denver",
    delayMinutes: 45,
    newDeparture: "6:15 PM",
    gate: "C12",
  },
});

curl -X POST https://notify.example.com/v1/notify \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "user": "usr_9142",
    "template": "flight-delayed",
    "channels": ["push", "sms", "email"],
    "priority": "critical",
    "data": {
      "flight": "UA 2043",
      "destination": "Denver",
      "delayMinutes": 45,
      "newDeparture": "6:15 PM",
      "gate": "C12"
    }
  }'

workflow("cart-reminder", async ({ step, event }) => {
  await step.wait("45m");

  const ordered = await step.waitForEvent("order.placed", {
    timeout: "6h",
    match: { cartId: event.cartId },
  });

  if (ordered) return;                 // they bought. say nothing.

  await step.notify({
    template: "cart-reminder",
    channels: ["push", "email"],
    fallback: true,
    data: { items: event.items, cartUrl: event.cartUrl },
  });
});

# when the cart goes quiet, start an instance
curl -X POST https://notify.example.com/v1/workflows/trigger \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "cart-reminder",
    "user": "usr_9142",
    "input": {
      "cartId": "cart_771",
      "items": ["Nike Pegasus 41"],
      "cartUrl": "https://shop.co/cart/771"
    }
  }'

# later, when they check out, this wakes the instance and cancels the nudge
curl -X POST https://notify.example.com/v1/events \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "order.placed",
    "properties": { "cartId": "cart_771", "userId": "usr_9142" }
  }'

workflow("cart-recovery", async ({ step, event }) => {
  await step.wait("45m");

  const boughtEarly = await step.waitForEvent("order.placed", {
    timeout: "6h",
    match: { cartId: event.cartId },
  });
  if (boughtEarly) return;

  await step.notify({
    template: "cart-reminder",
    channels: ["push"],
    data: { items: event.items },
  });

  await step.wait("24h");

  const boughtLate = await step.waitForEvent("order.placed", {
    timeout: "24h",
    match: { cartId: event.cartId },
  });
  if (boughtLate) return;

  await step.notify({
    template: "cart-discount",
    channels: ["email"],
    data: { items: event.items, code: "SAVE10", expiresHours: 24 },
  });
});

curl -X POST https://notify.example.com/v1/workflows/trigger \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "cart-recovery",
    "user": "usr_9142",
    "input": { "cartId": "cart_771", "items": ["Nike Pegasus 41"] }
  }'

# either checkout event ends the run, whichever stage it is in
curl -X POST https://notify.example.com/v1/events \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "name": "order.placed", "properties": { "cartId": "cart_771" } }'

workflow("trial-onboarding", async ({ step, event }) => {
  const uid = event.userId;

  await step.notify({ template: "welcome", channels: ["email"] });

  await step.wait("1d");

  const startedDay1 = await step.waitForEvent("project.created", {
    timeout: "1d",
    match: { userId: uid },
  });
  if (!startedDay1) {
    await step.notify({
      template: "first-project-nudge",
      channels: ["email", "push"],
      fallback: true,
      data: { minutes: 3 },
    });
  }

  await step.wait("2d");

  const startedDay3 = await step.waitForEvent("project.created", {
    timeout: "2d",
    match: { userId: uid },
  });
  if (startedDay3) {
    await step.notify({ template: "activation-congrats", channels: ["push"], priority: "low" });
    return;                                   // they are onboarded. stop here.
  }

  await step.notify({
    template: "smaller-goal",
    channels: ["email"],
    data: { suggestion: "Start with a single page" },
  });

  await step.wait("4d");

  const startedDay7 = await step.waitForEvent("project.created", {
    timeout: "4d",
    match: { userId: uid },
  });
  if (startedDay7) return;

  // hand them over to the win-back campaign and stop sending onboarding mail
  await step.run("mark-dormant", async () => {
    await db.users.tag(uid, "never-activated");
  });
});

# start it from your signup handler
curl -X POST https://notify.example.com/v1/workflows/trigger \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "trial-onboarding",
    "user": { "id": "usr_9142", "email": "[email protected]" },
    "input": { "userId": "usr_9142", "plan": "pro-trial" }
  }'

# every time they do the thing that matters, post it. any stage can exit on it.
curl -X POST https://notify.example.com/v1/events \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "name": "project.created", "properties": { "userId": "usr_9142" } }'

workflow("recover-payment", async ({ step, event }) => {
  await step.notify({
    template: "payment-failed-soft",
    channels: ["email"],
    data: { amount: event.amount, invoiceUrl: event.invoiceUrl },
  });

  await step.wait("72h");

  const paidAfterRetry = await step.waitForEvent("invoice.paid", {
    timeout: "48h",
    match: { customerId: event.customerId },
  });
  if (paidAfterRetry) {
    await step.notify({ template: "payment-recovered", channels: ["email"] });
    return;
  }

  await step.notify({
    template: "payment-urgent",
    channels: ["sms", "email"],
    fallback: true,
    priority: "high",
    data: { amount: event.amount, suspendsOn: event.periodEnd },
  });

  await step.wait("48h");

  const paidAfterSms = await step.waitForEvent("invoice.paid", {
    timeout: "24h",
    match: { customerId: event.customerId },
  });
  if (paidAfterSms) {
    await step.notify({ template: "payment-recovered", channels: ["email"] });
    return;
  }

  // your team, not the customer. different audience, different channel.
  await step.notify({
    topic: "billing-ops",
    template: "churn-risk",
    channels: ["slack"],
    priority: "high",
    data: { customerId: event.customerId, mrr: event.amount, daysOverdue: 5 },
  });

  await step.notify({ template: "final-notice", channels: ["email"], priority: "high" });
});

# from your Stripe webhook handler on invoice.payment_failed
curl -X POST https://notify.example.com/v1/workflows/trigger \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "recover-payment",
    "user": "usr_9142",
    "input": {
      "customerId": "cus_M4x",
      "amount": "$49.00",
      "invoiceUrl": "https://billing.co/i/8812",
      "periodEnd": "2026-09-12"
    }
  }'

# and on invoice.payment_succeeded, which ends the run at whichever rung it is on
curl -X POST https://notify.example.com/v1/events \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "name": "invoice.paid", "properties": { "customerId": "cus_M4x" } }'

workflow("cancellation-rescue", async ({ step, event }) => {
  // 1. always confirm. transactional, so the template carries no topic.
  await step.notify({
    template: "cancellation-confirmed",
    channels: ["email"],
    data: { accessUntil: event.periodEnd, plan: event.plan },
  });

  await step.wait("1h");

  // 2. a change of heart in the first hour is common. do not sell to them.
  const changedMind = await step.waitForEvent("subscription.resumed", {
    timeout: "1h",
    match: { customerId: event.customerId },
  });
  if (changedMind) return;

  // 3. pick the offer from what they actually used, once, not on every replay
  const offer = await step.run("choose-offer", async () => {
    const usage = await billing.usageFor(event.customerId);
    return usage.hoursLastMonth > 20
      ? { discount: "50%", months: 3 }
      : { discount: "30%", months: 2 };
  });

  await step.notify({
    template: "winback-offer",
    channels: ["email", "push"],
    fallback: true,
    data: offer,
  });

  await step.wait("48h");

  const cameBack = await step.waitForEvent("subscription.resumed", {
    timeout: "48h",
    match: { customerId: event.customerId },
  });
  if (cameBack) {
    await step.notify({ template: "welcome-back", channels: ["email"] });
    return;
  }

  await step.notify({ template: "exit-survey", channels: ["email"], priority: "low" });
});

curl -X POST https://notify.example.com/v1/workflows/trigger \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "cancellation-rescue",
    "user": "usr_9142",
    "input": {
      "customerId": "cus_M4x",
      "plan": "Standard",
      "periodEnd": "2026-10-01"
    }
  }'

# posting this at any point ends the run early
curl -X POST https://notify.example.com/v1/events \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "name": "subscription.resumed", "properties": { "customerId": "cus_M4x" } }'

workflow("unread-escalation", async ({ step, event }) => {
  await step.notify({
    template: "new-message",
    channels: ["push"],
    data: { from: event.senderName, preview: event.preview },
  });

  const openedSoon = await step.waitForEvent("thread.opened", {
    timeout: "20m",
    match: { threadId: event.threadId, userId: event.userId },
  });
  if (openedSoon) return;

  await step.notify({
    template: "unread-message",
    channels: ["email"],
    data: { from: event.senderName, preview: event.preview, url: event.threadUrl },
  });

  const openedLater = await step.waitForEvent("thread.opened", {
    timeout: "2h",
    match: { threadId: event.threadId, userId: event.userId },
  });
  if (openedLater) return;

  if (event.urgent) {
    await step.notify({ template: "unread-urgent", channels: ["sms"], priority: "high" });
  }
});

# when a message arrives for someone who is offline
curl -X POST https://notify.example.com/v1/workflows/trigger \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "unread-escalation",
    "user": "usr_9142",
    "input": {
      "threadId": "thr_88",
      "userId": "usr_9142",
      "senderName": "Alex",
      "preview": "are we still on for 6?",
      "threadUrl": "https://app.co/t/88",
      "urgent": false
    }
  }'

# wherever a thread gets opened in your app
curl -X POST https://notify.example.com/v1/events \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "thread.opened",
    "properties": { "threadId": "thr_88", "userId": "usr_9142" }
  }'

await notifkit.notify({
  segment: "active-last-24h",
  template: "service-degraded",
  channels: ["email"],
  priority: "low",                       // its own lane, behind everything transactional
  campaign: "incident-2026-09-12",
  data: { service: "Checkout", statusUrl: "https://status.example.com" },
});

// when it is fixed, same segment, same campaign label
await notifkit.notify({
  segment: "active-last-24h",
  template: "service-restored",
  channels: ["email"],
  priority: "low",
  campaign: "incident-2026-09-12",
  data: { service: "Checkout", downtimeMinutes: 39 },
});

curl -X POST https://notify.example.com/v1/notify \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "segment": "active-last-24h",
    "template": "service-degraded",
    "channels": ["email"],
    "priority": "low",
    "campaign": "incident-2026-09-12",
    "data": { "service": "Checkout", "statusUrl": "https://status.example.com" }
  }'

# when it is fixed, same segment, same campaign label
curl -X POST https://notify.example.com/v1/notify \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "segment": "active-last-24h",
    "template": "service-restored",
    "channels": ["email"],
    "priority": "low",
    "campaign": "incident-2026-09-12",
    "data": { "service": "Checkout", "downtimeMinutes": 39 }
  }'

workflow("incident-escalation", async ({ step, event }) => {
  const page = {
    severity: event.severity,
    summary: event.summary,
    runbook: event.runbook,
  };

  await step.notify({
    topic: "oncall-primary",
    template: "incident-page",
    channels: ["push", "sms", "slack"],   // no fallback: wake them on all three
    priority: "critical",
    data: page,
  });

  const ackedByPrimary = await step.waitForEvent("incident.acknowledged", {
    timeout: "5m",
    match: { incidentId: event.incidentId },
  });
  if (ackedByPrimary) return;

  await step.notify({
    topic: "oncall-secondary",
    template: "incident-page",
    channels: ["push", "sms", "slack"],
    priority: "critical",
    data: { ...page, escalation: 1 },
  });

  const ackedBySecondary = await step.waitForEvent("incident.acknowledged", {
    timeout: "5m",
    match: { incidentId: event.incidentId },
  });
  if (ackedBySecondary) return;

  await step.notify({
    topic: "engineering-managers",
    template: "incident-page",
    channels: ["push", "sms", "slack"],
    priority: "critical",
    data: { ...page, escalation: 2 },
  });
});

# from your alerting rule
curl -X POST https://notify.example.com/v1/workflows/trigger \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "incident-escalation",
    "input": {
      "incidentId": "inc_5512",
      "severity": "SEV-1",
      "summary": "checkout-api error rate 31%, p99 8.4s",
      "runbook": "https://wiki.internal/runbooks/checkout"
    }
  }'

# when someone hits acknowledge
curl -X POST https://notify.example.com/v1/events \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "name": "incident.acknowledged", "properties": { "incidentId": "inc_5512" } }'

import { registerTransport } from "notifkit";
import { ResendTransport } from "@notifkit/provider-resend";
import { SesTransport } from "./transports/ses.js";   // one you wrote

// higher number is tried first
registerTransport(new ResendTransport({ apiKey: process.env.RESEND_KEY!, from: "[email protected]" }), 10);
registerTransport(new SesTransport({ region: "us-east-1", from: "[email protected]" }), 5);

# transports are server boot config, so there is no HTTP call to register one.
# what you can check over HTTP is what happened to a message afterwards:
curl -s https://notify.example.com/v1/notifications/{taskId} \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY"

# every attempt, which provider took it, and the response it gave
curl -s "https://notify.example.com/v1/notifications/logs?limit=20" \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY"

// one message, end to end: every attempt, provider response and timing
const { status, logs } = await notifkit.getNotificationStatus(taskId);

// a whole campaign
const { totals, warnings } = await notifkit.getCampaignStats("incident-2026-09-12");

// why did this person get nothing? usually the answer is here.
const { suppressions } = await notifkit.listSuppressions({ target: "[email protected]" });

// what is parked and waiting to go out later
const { scheduled } = await notifkit.getScheduledMessages();

# one message, end to end
curl -s https://notify.example.com/v1/notifications/{taskId} \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY"

# a whole campaign
curl -s https://notify.example.com/v1/campaigns/incident-2026-09-12/stats \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY"

# why did this person get nothing?
curl -s "https://notify.example.com/v1/[email protected]" \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY"

# what is parked and waiting
curl -s https://notify.example.com/v1/notifications/scheduled \
  -H "Authorization: Bearer $NOTIFKIT_API_KEY"