Order Shipped
The order has left. The tracking link is the entire point of the message.
Customer and machine communication infrastructure
Your software. Your equipment. One place that governs both.
Send transactional notifications, take readings from the machines you run, honour every preference and quiet hour, render approved templates and prove exactly what happened — on one set of rules, for the order that shipped and the freezer that failed alike.
API · SDK · Webhooks · Managed delivery · Alerting · Preferences widget
await notifhq.notify("commerce.order.shipped", { recipient: "cus_1284", order_id: "ORD-9218", tracking_url: "https://…", });
You should not have to build this again
The first notification takes an afternoon. Then comes everything around it.
NotifHQ packages these behind one communication layer.
What you get instead
Everything above is the same job done again in every product that sends anything. NotifHQ does it once, as a contract rather than a codebase: you declare what a message is, and we own the templates, the preferences, the consent, the retries, the holding back, the evidence and the deleting — behind one API.
One kind of message, what it has to carry, who may receive it and on which channels. 62 are declared already.
Writing the message, checking preferences and consent, respecting quiet hours, retrying, holding back, tracking where it got to and keeping the evidence — 12 capabilities, each with its stages written down.
A timeline that answers 'did they get it?' without a provider's logs, and 71 reason codes so every refusal explains itself.
Nothing here is a framework you assemble. It is a contract you publish.
How it works
There is no SDK ceremony and no queue to run. You declare what a message is once, install or write its contract, call one endpoint, and read back what happened to it.
Nothing in this list is a future step. Every count on this page is read from the registries at build time.
More than a send endpoint
Your application describes what happened. NotifHQ decides how that communication is produced, whether it is permitted, how it is rendered, where it goes and what is recorded.
Your product emits4
NotifHQ owns12
Reaches people on3
3 channels, each with its own delivery states, evidence and preference rules.
Typed notifications
Define a communication once. We then know what it has to carry, which channels it may use, whether someone can opt out of it, how repeats are collapsed, and how long it stays worth sending.
The order has left. The tracking link is the entire point of the message.
A message arrives, and is measured against it
62 kinds of message are written down today, across 20 parts of a business.
The rule everything else follows
Most tools collapse all of that into one green tick. We keep the steps apart — in the API, in the numbers you report on, and in the history of every single message — because the moment they merge you can no longer answer the only question that matters when a customer says they never got it.
9 steps between asking for a message and it arriving, and 4 ways it can stop short. Whichever way it stops, the reason is recorded and you can go and read it.
An “open” is a hidden image being fetched, and mail apps fetch, cache or block those on their own. So we call it an open observation and name the number for what it actually measures.
Evidence, not assertion
Answer it from stored state, in seconds, without opening a transport's logs and hoping they are still in retention. Every state transition writes an append-only, hashed evidence row carrying two separate times: when the world produced the signal, and when we recorded it.
81 event families emit evidence before anything reacts to it.
Do not start from a blank screen
A pack installs the message types, what each must carry, the contracts, the templates, the routing, the opt-out categories and the reporting together — so a team starts with a shared vocabulary instead of assembling one.
The order has left. The tracking link is the entire point of the message.
A charge did not succeed and the recipient's service is at risk.
A short-lived passcode proving control of a channel. The single most latency-sensitive message the platform carries.
Tells a recipient their account was accessed from somewhere new, and gives them a way to act.
36 packs: 20 sector, 13 functional and 3 compliance.
Respect preferences automatically
Preferences, consent, hold-backs, quiet hours and sending limits are decided as part of sending. You call the same endpoint every time.
They do not drop. Unless the message expires first — in which case it is marked expired, with evidence.
Never an error, and never a message that quietly vanishes. Every one carries a reason you can read.
No contract, purpose or category overrides it.
71 reasons on the list, so “why didn’t this go out?” is answerable in a support conversation without anybody reading code.
Replies come back
A notification you cannot reply to is a broadcast. Replies land on the record of the send that prompted them, and a team works them there.
The person replying is the person your preference centre and your do-not-contact list already know.
Assignment, status and history, on the same record as the message that started it.
What arrives is sorted, kept and deleted on exactly the rules that govern what leaves.
Machines as well as people
Most communication platforms assume the thing worth telling somebody about happened inside a web application. A great deal of it happens on a ward, a shop floor, a yard, a laboratory, or in the back of a trailer — and the people who need to hear about it have the same phones, the same quiet hours and the same right to an explanation as your customers.
Watched by a pack you can install today
23 declared classes in total. The rest are classes you can declare and report observations against now.
Declare the things you track and report against them. Nothing here asks you to replace a sensor gateway, a building management system or a fleet platform: they already speak HTTP, and this is what happens after they do.
Machines as well as people
A condition becomes true about something you track — a cold store above its range, a spindle faulted, a barrier forced — and the work is not sending a message. It is deciding whether this is the four-hundredth time this hour, who hears it, what happens when nobody answers, and what you can show an auditor afterwards. Report every reading; deciding what is worth waking somebody for is our job, not yours.
4 industry packs install 8 conditions, each with the quiet rules that kind of equipment actually needs, across 23 declared classes of thing.
Installed, not configured
Each of these arrives with the quiet rules that kind of equipment actually needs, worked out by somebody who has been woken up by it. Install the pack and the condition, its severity and its quiet rules come with it.
Beyond these, every declared class is yours to track: report observations against a patient monitor, a diagnostic system or an autonomous vehicle and the same quiet rules, severity and chasing apply. A pack is a head start, not the boundary.
Answered, or ended
Most alerting tools have one way to finish: resolved. So a freezer that recovered and a freezer somebody muted at two in the morning leave the same trace, and three months later nobody can tell you which happened. Acknowledging is not fixing either — it stops the chasing and nothing else — and a tool that treats it as resolution is how a dashboard shows green while equipment is still failing.
The condition became true and nobody has taken it. The entry state, and the only one from which escalation runs.
→ acknowledged · cleared · closedA person or an agent has said they have it. The condition may still be true — acknowledging is not fixing — so this stops the chasing and nothing else. Conflating it with resolution is how a board shows green while a freezer is still warming.
→ cleared · closedThe source reported that the condition is no longer true. Observed, not asserted: the freezer came back to temperature and said so.
A person ended the alert without the source clearing it — a false positive, a known fault, equipment taken out of service. Asserted, not observed, and never merged with 'cleared'.
4 states, and the last 2 are kept apart on purpose: one is what the equipment reported, the other is what a person decided. Nothing returns to raised — acknowledging stops the chasing and nothing else.
Which one happened is a question an auditor will ask, so it is a state the platform keeps rather than a note somebody remembered to write.
One roof
Both are a fact that became true, a decision about who should hear it, a message somebody either received or did not, and a question somebody asks three months later. Running those as two systems means two sets of preferences, two quiet-hours policies, two audit trails and two answers to what happened — and the second system is always the one nobody governed.
The same contracts, the same preferences, the same rules and the same evidence, whether it came from your software or from your equipment.
Where it is, and how you know
A cold store is over temperature. Which one, in which building, on which site, and who is the person nearest it right now? Somewhere is a place you declare. Somewhere else is a position something reported, with an accuracy and a source attached. Keeping those apart is the difference between routing an engineer to a depot and routing them to a trailer that left it two hours ago.
Both are API objects, not attributes: POST /v1/locations declares a place, and GET /v1/subjects/{id}/positions is where a thing has been.
Process first, store less
The same step runs over everything that arrives — messages, inbound mail, attachments, ticket replies, webhook bodies. Anything your contract did not ask for is dropped before it is written down, so it never needs classifying and never needs protecting.
Detection gives the same answer every time, and it is the answer that counts. A card number is caught by doing the arithmetic, not by looking similar — an order reference that looks like a card is not one, and an embedding never gets a say in a security decision.
Measured, not claimed
Consent, hold-backs, quiet hours, where the person is, what industry you are in, and every compliance pack you have installed — 30 policies can bear on a single send, and the ones that apply to your workspace are weighed into one answer. Not a claim somebody typed: a real measurement runs on every build and fails it if the number slips.
Measured over 50,000 runs against the heaviest set-up — every compliance pack installed — rather than the lightest.
Drop-in customer experiences
Preferences, consent and data requests your users control, embedded in your product and enforced by the same thing that does the sending. Each renders in a shadow root, so your CSS cannot break it and its styles cannot leak into your page.
The workspace API key never reaches the browser. Widgets authenticate with a short-lived, recipient-scoped token minted server-side — and the widget refuses a token that looks like an API key.
API first
One call from you. Everything below is ours, and none of it appears in your code or your on-call rota.
POST /v1/notifications
one call
13 stages behind one call. They emit 13 events between them, and at 10 of them a message can stop for a reason you can read. None of it is in your code.
Every failure names a registered reason code and its decision. A recipient who opted out is their choice, not your bug, and the SDK tells you which.
A policy denial is never retried — it would produce the identical denial forever and bury the outcome.
Timing-safe checking with a time limit, so a captured request cannot be replayed forever.
137 endpoints and 174 operations, generated from the same document the SDK is built from.
Compliance packs
Compliance packs are sets of controls that run in the same pipeline as your sends — sorting sensitive data, spotting it, keeping less of it, hiding it, deleting it on time and answering a person who asks what you hold. The control happens before anything sensitive reaches a log, a search index or a report.
Executable controls installed by each compliance pack
110 executable controls across 3 packs, counted from the packs themselves. Installing a pack installs these; it does not certify anything.
A compliance pack is a set of technical controls. It is not a certification, a signed statement of compliance or a legal status, and we will not describe it as one. Genuine standing under health-privacy law also needs agreements no software can sign for you.
What you get
Each capability is switched on, billed and controlled on its own, so you run the parts you need and pay for those. The core ones come with every workspace; the rest are bought and switched on when you want them.
Installed with every workspace. Not separately billed.
Installed and billed per workspace, each governed on its own.
Every capability here is one you can switch on today, governed on its own terms and billed on its own line.
Built to compound
Templates share one definition of what a message carries. Packs share one vocabulary. The widgets read the preferences the sending obeys. Each capability is more useful because the others exist — which is a harder thing to reproduce than a send endpoint.
One layer, several jobs
One API, typed requests, an SDK, signed webhooks and far fewer delivery surprises in production.
Reusable communication patterns, an embeddable preferences centre and engagement measured honestly.
A timeline that answers “did they get it?” without a provider's logs.
Sorting sensitive data, keeping only what is needed, deleting on time and keeping the evidence — set up once, applied to every send.
Designed for teams building
Each sector pack installs the notification types, contracts and templates that sector needs, drawn from the same dictionary.
We do not show customer logos. When there are references worth naming, they will appear here with permission and not before.
Against the alternatives
Most teams reach one of these three. The columns describe what each KIND of answer is designed to do — not a scorecard of any particular vendor, because a feature table about someone else's product is out of date the week it is written.
| Build it yourself Your team, your queue, your on-call | An email service provider A delivery API and a template editor | NotifHQ A governed communication layer | |
|---|---|---|---|
| What you integrate against | Your own abstraction, rewritten each time a channel or a rule is added. | A send endpoint per provider, plus whatever you build around it. | One API: 174 operations across 137 paths, with a generated SDK and signed webhooks. |
| What a message is | Whatever the calling code passes. Shape drift is found in production. | A template and the data it happens to mention. | A declared type with a published contract. 205 of them check what you sent before a word is written, so a missing variable fails at publish rather than at send. |
| Preferences and consent | A table, a settings screen, and a branch before every send that somebody has to remember. | Unsubscribe for marketing mail, typically per list. | Worked out by us, per category and channel, with quiet hours and consent evidence. Your code does not branch. |
| Answering “did they get it?” | Parse provider logs and hope the retention window is long enough. | Provider-side event streams, for as long as that provider keeps them. | An evidence timeline you own, with 81 event families emitting today and 71 reason codes so a refusal explains itself. |
| When it refuses | An exception, and a retry loop somebody wrote at 2am. | A provider error code, mapped by you to something your team understands. | A registered reason code and its class. A policy denial is never retried, because it would produce the identical denial forever. |
| Replies | A second system, holding half the history. | Usually out of scope; inbound is a different product. | A shared inbox on the same contracts that sent the message, threaded to the send that prompted it. |
| Time to the first governed send | Sending is an afternoon. The year after it is the part nobody estimates. | Minutes to a send; the governance is still yours to build. | Install a pack and call one endpoint. 205 notification types arrive already contracted. |
Only the NotifHQ column makes claims we hold ourselves to, and every figure in it is read from this repository's registries at build time. The other two describe the shape of the category; a specific product in either may well do more, and if you are comparing against one in particular, ask us and we will answer about that one honestly.
Pricing
Volume is a capacity dimension inside a plan, never the whole of it. Billing is counted from the record of what actually happened: a message your rules stopped was never delivered, and is not billed as though it was.
A capability your plan does not include is absent rather than locked — it does not appear in your dashboard or your API reference.
What it replaces
Sending is an afternoon. The year after it is templates, preference screens, consent records, retry logic, holding the wrong ones back, a delivery log somebody has to read, and an auditor asking for evidence. Every number below is what arrives already built.
Every number here is read out of the list that owns it when this page is built, so none of them is an estimate and none of them is a guess.
Beyond the plan
Each of these is a capability with its own contract, bought against the plan you already have rather than by moving up a tier. A card says what the add-on sells, and where a name could reasonably be read wider than the thing behind it, what it does not.
Replies come back. Inbound mail is parsed, attributed to the person it came from and threaded to the notification it answers, and a team works it as tickets with assignment and status on the same evidence chain as the outbound send.
A document is identified by its own contents on upload, read if it carries text, sorted against the classes you declared, and routed to a person when it cannot be sure. That is the whole of it.
Not includedOptical character recognition, or reading fields out of a document. A PDF or a scan is stored and reviewable; no amount, date or supplier is extracted from it. Where classification cannot answer, it says so and routes the document to a person rather than guessing.
One query across notifications, tickets, documents and recipients, authorised after the query and before the response so an index can never return a row the caller may not see.
Executable controls in the send path: classification, detection, keeping less, redaction, retention windows and subject-access workflows, applied before sensitive data reaches a log, an index or an analytics table.
Your name and your styling on the widgets your recipients use — preferences, consent, data requests — with no NotifHQ branding on any of them.
Additional verified sending domains on one workspace, each with its own signing keys, its own reputation and its own verification record.
Longer retention windows on the classes that hold your evidence, so a record survives as long as the rule that needs it rather than as long as the default.
A workspace declares the things it tracks and the conditions worth knowing about, and reports observations over HTTP. We decide what becomes a message: the quiet rules run first, an alert is raised or folded into another or withheld with a reason, acknowledging it stops the chasing, and a timer escalates it. Every observation is stored whether or not it raised anything, so the silences are as auditable as the alerts.
Not includedReaching equipment directly over a shop-floor protocol, or commanding it. Telemetry arrives over HTTP, which is how a sensor gateway or fleet platform already speaks. MQTT, OPC-UA, Modbus, LoRaWAN and serial are not carried, and nothing here sends a command to a machine.
Secure by design
Centralising communication takes delivery credentials out of your application surfaces.
Can reach a delivery provider1 of 5
MAIL
No path to a provider at all4 of 5
DBCOMMSRATE_LIMITBASE_URLAI
DBEMAIL
DBSESSIONSAI
COMMSRATE_LIMIT
A credential taken from anything below the line sends nothing: there is no code under it that can call a vendor.
A key is bound to one workspace and one environment. A test key cannot cause a real delivery.
Recipient-scoped, minted on your server. Your key never reaches a browser.
Verify before you act, with replay protection.
Every administrative change records what it looked like before and after.
Before you ask
It answers with a registered reason code and its class — 71 of them — and the refusal is recorded as evidence. A policy denial is never retried, because it would produce the identical denial forever and bury the outcome.
In the United States. That is where this deployment stores data, so if your data has to live somewhere else, tell us before you start rather than after: it is a database we would have to stand up, not a setting we would have to change. We tell you where your data is rather than promising it cannot leave, because those are different undertakings and only one of them is ours to give: this database is placed by a best-effort hint, not held by a binding jurisdiction. Ask us for a jurisdiction-backed region and we will tell you what exists today. What you send is trimmed before anything stores it, so a field your contract did not ask for is dropped at the door rather than written down and cleaned up later.
As you. Each sending domain gets its own DKIM key and every message carries the workspace's own legal signature. A domain is verified against the address it actually sends from.
No, and we will not describe it as one. A pack is a set of executable controls that run in the same pipeline as your sends. Genuine standing under health-privacy law also needs agreements no software can sign for you.
Keep it. Providers sit behind a transport worker and nothing else in the estate may reach one, so swapping or adding a provider changes one binding rather than your integration.
174 operations across 137 paths, 12 capabilities, 81 kinds of event emitting evidence, and 62 notification types in the shared dictionary. Every number on this page is read out of the list that owns it when the page is built, so none of them is a figure somebody typed.
If the answer you need is not here, the contact form goes to a person, not a queue.
Start with one notification. Add templates, preferences, widgets and evidence as you need them.
Talk to a person
One form, and a person reads every one. Pick what you need and the fields change; nothing here depends on a script running.
A person reads every one of these. We will reply to the address you gave us.
Please check the highlighted fields. Something went wrong on our side. Please email info@notifhq.com and we will pick it up.