Batch events into one daily email
Turn fifty notifications a day into one summary email: send each event as it happens, and on the schedule you choose, hourly or daily, everything arrives together in order of arrival. No events, no email. Pay per use, no subscription.
Fifty notifications a day train people to ignore all fifty.
How a digest works
You keep sending events exactly as they happen, each with a title, a short text and, if you like, a severity and a time. They wait in a named collection until its schedule fires: every hour, every day or a custom window you set for that collection. At that moment everything collected becomes one readable email, formatted and in plain text, grouped and ordered by arrival time, and goes to the recipients on file. If nothing was collected, nothing is sent, so you only get mail when there is something to read. Adding an event returns at once; the email itself leaves on schedule.
Good uses and common mistakes
A monitoring agent that reports every warning can produce one 7 am email listing them by severity instead of forty pings. Account administrators can get one daily summary of sign-ups, cancellations and support tickets, and a team lead can review one morning email instead of fifty job logs. The usual mistake is putting urgent problems in a digest: anything that needs action now should go out as an immediate alert, keeping the digest for what can wait. Another is mixing unrelated events in one collection; give orders and errors their own collections and schedules.
How the batching actually works
When the bucket's schedule triggers (hourly, daily, or a custom cron-like window you configure per bucket), everything queued is rendered into a single HTML and plain-text email, grouped and ordered by the time it arrived, and sent to the recipients on file. If nothing was queued, no empty email goes out; you only get mail when there's something to read.
What you can do with it
Nightly ops summary
A monitoring agent posts every warning-level event through the day; instead of forty pings, the ops channel gets one 7am email listing them all by severity.
SaaS product digest for admins
Account admins get a single daily email of new signups, cancellations and support tickets instead of a real-time feed nobody reads.
Batch job reporting
A fleet of scheduled ETL jobs each posts its pass/fail status; the team lead reviews one consolidated morning email rather than fifty job logs.
Content moderation queue recap
Flagged items accumulate through the day and land in one digest for the moderation lead to triage in a single sitting.
FAQ
Is there a free tier for notify.digest?
There's no free tier — free tiers get abused and slow everyone down. No subscription, no tokens, no invented credits, and a failed task is never charged.
Can I run multiple digests with different schedules?
Yes, buckets are independent, so you can run an hourly digest for on-call severity events and a separate daily digest for general activity at the same time.
What happens if a digest send fails?
A failed task is retried automatically up to three times; if it still fails you get a clear error and are never charged for that send.
Can I include severity levels or tags in each entry?
Yes, each entry accepts an optional severity and free-form tag so the compiled email can group and highlight the entries that matter most.
Is my event data kept after the digest is sent?
No, entries and the compiled email are deleted after the stated retention window and are never used for training.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
One authenticated POST creates the task; the result comes back by webhook or a signed link. This capability is currently available through the API, not as an interactive Web tool.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/notify/digest \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"cron":"0 9 * * 1"}'const res = await fetch("https://api.kit.forhosting.com/notify/digest", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"cron": "0 9 * * 1"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/notify/digest",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"cron": "0 9 * * 1"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/notify/digest", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"cron":"0 9 * * 1"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"cron":"0 9 * * 1"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/notify/digest", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"cron": "0 9 * * 1"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "notify.digest",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
The digest API collects the events you send it and ships one readable summary email on the schedule you choose, so the inbox becomes a signal again instead of noise.
Built for teams drowning in single-event emails
You keep sending events exactly as they happen; we hold them and compose the summary.
How the batching actually works
Each call to POST /notify/digest adds one entry — a title, a short body, an optional severity and timestamp — to a digest bucket you name.
A quiet return to how email was meant to work
Digest emails are not a new idea — mailing lists and newsletter software have batched updates for decades — but most application notification systems skip that layer entirely and fire one message per event because it's the easiest thing to code. We built this endpoint specifically so you don't have to write your own batching, cron job and templating layer just to get back to the sane default of one email a day.
Fits into pipelines you already run
Pair it with an alert-routing step upstream to decide what deserves a digest versus an immediate ping, or point dozens of independent services at the same bucket to get one unified daily report across your whole stack. Because the endpoint is async, your event source fires POST /notify/digest and moves on immediately — task_id comes back in milliseconds and the actual send happens on schedule, decoupled from whatever triggered the event.
What lands in your inbox
The final email lists each entry with its timestamp and severity marker, grouped chronologically, with a subject line summarizing the count and top severity so you can triage from the inbox list view alone before opening it. Delivery confirmation comes back the same way as any other task here: a signed webhook call, or a signed link valid for 24 hours if you'd rather poll.
Technical questions
How does the daily digest email API decide when to send?
You set a schedule per bucket — hourly, daily or a custom window — and every entry posted to that bucket in the interval is compiled into one email when the window closes.
What does it cost to send a digest?
It's $0.002 per POST /notify/digest request that queues an entry, plus $0.0035 for each digest email actually sent — you're never billed for a digest window that had nothing to send.
How do I get the result — webhook or polling?
You can register a signed webhook to be notified the moment the digest is sent, or fetch a signed link that stays valid for 24 hours if you prefer to poll.