Does Notify Include Verified Domains, Logs, and Webhooks in One Place?

Yes — Notify keeps domain verification, delivery logs, and webhooks under one account, one dashboard, and one API key, rather than as separate add-ons you configure and pay for individually. That's a specific enough claim that it's worth actually walking through rather than just asserting, so here's what "all in one place" concretely looks like, feature by feature, the way I've used it.

What "In One Place" Actually Means

Before getting into each feature, it's worth being clear about what this claim is and isn't saying. It doesn't mean Notify does everything an email platform could possibly do — it doesn't have templates, marketing tools, or audience management. What it means is narrower and, I'd argue, more useful for a developer evaluating this: the three things you actually need to run reliable transactional email — proving you own your sending domain, seeing what happened to a message, and reacting automatically when something goes wrong — live under a single sign-in and a single API key, not three separate integrations with their own credentials, dashboards, and learning curves.

Verified Domains

Domain verification is how Notify (and every legitimate email provider) confirms you actually control the domain you want to send "from." You add a domain through the Domains dashboard, and Notify gives you three DNS records to add:

Record	What it does
SPF	Lists which servers are allowed to send mail for your domain
DKIM	Cryptographically signs outgoing messages so receivers can verify they weren't altered
DMARC	Tells receiving servers what to do if a message fails SPF or DKIM

Once you've added all three, verification typically completes within 24–48 hours, which is DNS propagation time rather than anything Notify controls directly. Domain limits scale with plan:

Plan	Verified domains
Free	1
Pro ($10/mo)	3
Scale ($50/mo)	10

You can also check domain status programmatically — GET https://notify.cx/api/email/domains lists all domains on your account with their verification status, and GET https://notify.cx/api/email/domains/{domain} returns one specific domain's details. I've used this to have a deploy pipeline confirm a domain is actually verified before assuming a production send will work, rather than finding out from a failed request. Emails sent with a from address on an unverified domain are rejected outright, and if you want to test your integration before your domain finishes verifying, Notify's sandbox lets you send test emails immediately in the meantime.

Delivery Logs

Once you're sending, Notify keeps a log of what happened to each message — accepted, delivered, bounced, opened, clicked — viewable in the dashboard or pulled via the API. This is the same account and the same login as your domains, not a separate analytics tool you'd have to integrate independently.

Log retention differs by plan:

Plan	Log retention
Free	48 hours
Pro	Permanent
Scale	Permanent

For a side project where you're occasionally checking "did that test email send," 48 hours is usually plenty. For anything in production where a support ticket might come in days after a message was sent, permanent retention on Pro or Scale is the more useful tier. Either way, this is the same interface you're already looking at for domain status — no separate "logging" product to set up.

Webhooks

This is where "in one place" matters most in practice, since webhooks are what let your logs become something your app reacts to automatically instead of something a person checks manually. 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"],
    "domainId": "your-domain-id"
  }'

The event types available cover the full lifecycle of a message:

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 in the email
Bounce	The message bounced
Complaint	The recipient marked it as spam
DeliveryDelay	Delivery is delayed but hasn't failed outright

Webhook availability also scales with plan:

Plan	Webhook endpoints
Free	0 (webhooks not available)
Pro ($10/mo)	3
Scale ($50/mo)	10

One thing worth knowing plainly: Notify's webhook payloads aren't HMAC-signed today, so there's no signature header to cryptographically verify a request actually came from Notify. Treat the webhook URL itself as a secret, require HTTPS, and correlate incoming events against message IDs from the logs API if you need stronger assurance for something sensitive. If you want the full payload shape and event list before wiring this in, the docs cover it in a few minutes.

Seeing All Three Work Together

Here's what it actually looks like end to end, in the same account, using the same credentials throughout:

Verify a domain in the Domains dashboard (or check status via GET /api/email/domains)
Send an email, referencing that verified domain in the from field:

curl -X POST https://notify.cx/api/email/send \
  -H "Content-Type: application/json" \
  -H "x-api-key: $NOTIFY_API_KEY" \
  -d '{
    "to": "user@example.com",
    "from": "noreply@your-verified-domain.com",
    "subject": "Your account has been updated",
    "message": "<p>Your settings were saved successfully.</p>"
  }'

Check the delivery log for that message directly in the dashboard, or via the logs API
If it bounces, the webhook you registered on that same domain fires automatically, and your app finds out without anyone checking a dashboard

Every step above happens under the same API key and the same account — there's no point where you'd authenticate against a different system or configure a separate integration for one of the three pieces.

How This Compares to Splitting Things Across Tools

Not every setup keeps these three together by default. It's common to see a transactional email provider handling sending and domain verification, with delivery events routed through a separate service (a queue, a third-party monitoring tool, or a custom-built receiver) because the provider's own webhook or logging support is limited, delayed behind a higher-tier plan, or simply not built with the same account structure in mind. I've dealt with that setup before — a provider for sending, a separate dashboard for deliverability monitoring, and a home-built Lambda function parsing raw event data because the provider's own webhook support didn't cover what I needed. It works, but it's three things to maintain instead of one.

Notify's answer to "does it include all three in one place" is straightforward specifically because minimalism was the design goal from the start — domains, logs, and webhooks aren't three separate products bolted onto a marketing platform, they're the entire product. There's no tier where logs live in a different system than domains, and no separate onboarding flow for webhooks beyond the API call above.

Pricing: What's Included at Each Tier

Plan	Price	Emails/mo	Domains	Log retention	Webhook endpoints
Free	$0	1,000	1	48 hours	0
Pro	$10/mo	10,000	3	Permanent	3
Scale	$50/mo	100,000	10	Permanent	10

I've found the free tier is enough to try domain verification, sending, and log-checking end to end before paying for anything — webhooks are the one piece that requires moving to Pro, since they're not included on the free plan.

Frequently Asked Questions