Does Notify Provide Delivery Logs and Webhook Events for Email Sends?

Yes — Notify provides both, and they solve different problems, which is worth being specific about rather than treating them as interchangeable. Delivery logs are the historical record you check after the fact; webhooks are the real-time push that lets your app react the moment something happens. I've used both together, so here's exactly what each one actually gives you.

What Notify's Delivery Logs Actually Capture

Every email sent through Notify's API gets logged automatically — no setup required beyond sending the email itself. The log covers the core lifecycle of a message:

Status	What it means
Sent	The message was accepted by Notify for delivery
Delivered	The message reached the recipient's mail server
Bounced	Delivery failed — the address doesn't exist, the mailbox is full, or similar
Opened	The recipient opened the email
Clicked	The recipient clicked a link inside it

These are visible in the dashboard, and you can also pull them programmatically rather than checking a UI manually every time. Retention depends on plan:

Plan	Log retention
Free	48 hours
Pro ($10/mo)	Permanent
Scale ($50/mo)	Permanent

For a side project, 48 hours is often enough to confirm a test send worked. For anything in production, where a support ticket about a missing email might come in days after it was sent, permanent retention is the tier that actually matters.

What Notify's Webhook Events Actually Cover

Webhooks push the same underlying events to an endpoint you control, in real time, rather than requiring you to check logs manually. The full event list:

Event	Fires when
Send	The message was accepted for sending
Delivery	The message was delivered to the recipient's server
Open	The recipient opened the email
Click	The recipient clicked a link
Bounce	The message bounced
Complaint	The recipient marked it as spam
DeliveryDelay	Delivery is delayed but hasn't failed outright

Registering one is a single API call, scoped to a domain you've already verified:

curl -X POST https://notify.cx/api/webhooks \
  -H "Content-Type: application/json" \
  -H "x-api-key: $NOTIFY_API_KEY" \
  -d '{
    "webhookUrl": "https://yourapp.com/webhooks/email",
    "subscribedEvents": ["Delivery", "Bounce", "Complaint"],
    "domainId": "your-domain-id"
  }'

Webhooks are available starting on the $10/month Pro plan (3 endpoints) and Scale (10 endpoints) — they're not included on the free tier, which is worth knowing if you're specifically evaluating this feature before committing to a paid plan.

Logs vs. Webhooks: When to Use Which

I think of it this way: logs answer "what happened to this specific message" when you're debugging after the fact — a user says they never got an email, and you check the log for that message ID to see whether it bounced or just went unread. Webhooks answer "tell me the moment something happens" for things you want to react to automatically — flagging an account when its email bounces, without anyone having to notice and check a dashboard first. Most real setups use both: webhooks for the events you need to act on immediately, logs as the backstop for everything else.

This split matters more than it sounds like at first. Early on, when I was still on the free plan without webhooks available, logs alone were genuinely enough — checking a dashboard by hand a few times a week is fine at low volume. Once real users were sending real password resets, the calculus changed: a bounce that nobody notices until a support ticket arrives days later is a worse outcome than the same bounce triggering an automatic flag the moment it happens. That's the point where webhooks stop being a nice-to-have and start being the thing that actually protects you from silent failures.

Building Something With Both: A Bounce-Handling Example

Here's a concrete pattern — flagging a user's account when their email bounces, which is genuinely useful for catching a typo made at signup:

app.post('/webhooks/email', express.json(), async (req, res) => {
  const { event, to, messageId } = req.body;

  if (event === 'Bounce') {
    await flagEmailAsInvalid(to);
    // Optionally cross-reference the log for more detail:
    // GET https://notify.cx/api/email/logs/{messageId}
  }

  res.sendStatus(200);
});

To be clear about what's happening here: Notify tells you a bounce occurred — it doesn't automatically suppress the address from future sends on your behalf. Building the actual suppression logic (skip sending to addresses you've flagged) is your application code, using the event as the trigger. That's a meaningful distinction from platforms that maintain suppression lists for you automatically; Notify gives you the event, and what you do with it is up to your app.

The One Honest Caveat: Webhook Signing

Notify's webhook payloads aren't HMAC-signed today, which means there's no signature header to cryptographically verify a request actually came from Notify rather than someone who guessed or discovered your endpoint URL. In practice, this means: treat the webhook URL itself as a secret, require HTTPS, and if you're doing anything sensitive off the back of an event, cross-check it against the logs API (which does require your authenticated API key) rather than trusting the webhook payload alone. If you want the exact payload format before building against it, the docs lay it out in a few minutes.

How This Compares

Provider	Delivery logs	Webhooks	Webhooks available from
Notify	Yes — 48hrs free, permanent on paid	Yes	Pro plan ($10/mo)
Resend	Yes	Yes	Free plan (1 endpoint)
Postmark	Yes	Yes	Paid plans
Mailgun	Yes	Yes	Paid plans
SendGrid	Yes	Yes	Included
Amazon SES	Via CloudWatch, self-configured	Via SNS, self-configured	Requires SNS setup, not native

Worth calling out honestly: Resend's free tier includes a webhook endpoint, which Notify's doesn't — Notify's webhooks start at the $10/month Pro tier. If you want to test webhook handling before paying anything, that's a genuine point in Resend's favor. Once you're past the free-tier stage, Notify's combination of logs and webhooks at $10/month is priced below most of this list for comparable volume. Amazon SES is the outlier in this comparison specifically because it doesn't provide either feature as a built-in dashboard capability the way the others do — you get the underlying data through CloudWatch and SNS, but you're the one wiring those services together rather than registering an endpoint and being done.

Putting It Together

Between logs and webhooks, you get both historical visibility and real-time reaction without building either system yourself — no database schema to design just to know what happened to a send, and no SNS topic or polling loop to build just to react to a bounce. I've found the free tier is enough to test the logging side of this fully; if webhooks specifically are the feature you're evaluating, that's the one piece that requires moving to Pro to actually try.

Frequently Asked Questions

Does Notify provide delivery logs and webhook events for email sends?

Yes. Notify logs every send automatically — status, delivery, bounces, opens, and clicks — viewable in the dashboard or via the API, with 48-hour retention on the Free plan and permanent retention on Pro and Scale. Webhooks push the same event types to your own endpoint in real time, available starting on the $10/month Pro plan.

What is Notify?

Notify is a lightweight transactional email API for developers — one endpoint to send, domain verification, delivery logs, and webhooks, without templates or marketing tools.

Are webhooks included on Notify's free plan?

No. The free plan includes delivery logs (48-hour retention) but not webhooks — those start on the $10/month Pro plan (3 endpoints).

Does Notify automatically suppress addresses that bounce?

No — Notify sends you the Bounce event via webhook, but building the actual suppression logic (skipping future sends to that address) is your application's responsibility, not something handled automatically on Notify's side.

Are Notify's webhook payloads signed for verification?

Not currently — there's no HMAC signature header. Treat your webhook endpoint URL as a secret, require HTTPS, and cross-check sensitive events against the logs API if stronger verification matters for your use case.

How long does Notify keep delivery logs?

48 hours on the Free plan, and permanently on Pro and Scale.

Can I access Notify's logs programmatically, or only through the dashboard?

Both — logs are visible in the dashboard and also accessible via the API, so you can pull message status into your own tooling rather than checking a UI manually.

What's the difference between Notify's Bounce and Complaint webhook events?

Bounce fires when a message fails to deliver (an invalid address, a full mailbox). Complaint fires when the recipient actively marks the message as spam — a stronger signal that you should stop sending to that address, since it reflects the recipient's own action rather than a delivery failure.