The event you filtered out never failed
You'll get this bug report one day. A customer says their invoices stopped syncing three weeks ago. Every request in the delivery log for that window returned 200. The dead letter queue is empty. The sender's dashboard shows no failures, no retries and a healthy endpoint. Everything is green, and the events are gone.
They weren't lost in transit. They were never sent. Somebody added a filter rule in the sender's dashboard, or the payload changed shape under an existing rule, and from then on the events stopped matching. No request went out, so there was nothing to fail.
Sender-side filtering is spreading, and it's a good feature. It's also the quietest way to drop webhooks we know of.
What Emailit shipped on September 27
On September 27, 2026, the transactional email API Emailit posted a webhook update to its changelog. The main item is payload filters that "deliver only the events whose data matches up to 25 rules." The docs give the obvious use case, a webhook limited to emails sent to one domain. Filters are available on Pro, Business and Custom plans. On Pay as you go, setting a payload filter returns a 403.
The same entry added a send-test button for every event type, a secret reset, and a retry schedule: 5 minutes, 30 minutes, 2 hours, 5 hours, then every 12 hours, up to 11 attempts. Emailit emails the workspace owner when an endpoint keeps failing and disables it after three days of continuous failures. A "Retry failed" action re-queues the failed requests from the last seven days and switches the webhook back on.
Now read those features together. Retries, failure emails, auto-disable and manual retry all act on requests that were attempted. A filtered event was never attempted, so none of that tooling will touch it. The docs don't say whether non-matching events are logged anywhere you can see. Until a sender tells you otherwise, assume they aren't.
Emailit is just the latest example. The decision about which events you receive has been drifting out of your code and into someone else's settings page for a while.
Event type subscriptions were always filters
You have been running sender-side filters for years. You just called them subscriptions.
A Stripe webhook endpoint has an enabled_events list. A GitHub repository webhook has an events array. Any provider that lets you tick boxes next to event names is filtering for you. Someone unticks invoice.payment_failed to quiet a staging endpoint, copies that config to production by hand, and you have the bug report from the top of this post.
Type filters only break when someone edits them. Content filters match on fields inside the payload, and they can break when nobody touches them at all. That's why the newer kind deserves more suspicion.
A rule that matched yesterday can stop matching today
A content filter is a predicate evaluated against a payload you don't control. The payload changes. The predicate doesn't.
Take the documented example, emails to one domain. A recipient domain can stop being example.com as far as the filter is concerned in plenty of ways. A customer starts sending from a subdomain. A field that held one recipient starts holding a list. Casing differs between two systems. The sender renames the field. Whether any of that breaks a given rule depends on operators the sender may not document in detail. You can't reason about it from your side.
We wrote about a Shopify field that changed from an array to an object in the post on payload shape changes. In that case the reshaped payload still arrived, and your parser could at least throw. Put a content filter in front and the sender evaluates the new shape, finds no match and drops it before any of your code sees it. The schema change and the data loss happen as one silent event.
Your reconciler will blame the wrong thing
If you run a reconciliation job, and you should, it will notice the gap eventually. Your records drift from the provider's and the job flags them. That's the safety net from the post on webhooks and state sync.
The problem is what the job concludes. It sees missing data and reports missing deliveries. Your on-call engineer checks the receiver, the queue, the load balancer and the sender's status page. The cause is a dashboard field none of those tools read. You can easily lose a day on a "delivery outage" that turns out to be a filter rule someone added during a demo.
So teach the reconciler about filters. When it finds an object with no matching event, have it run your copy of the filter rules against that object and say so: "missing, and would not have matched the configured filter." That one line turns a day of debugging into a ticket for whoever owns the integration settings.
Keep a copy of every filter in code
That assumes you have a copy. The sender's dashboard decides what gets sent. It shouldn't be the only place the rules are written down.
Put the predicate in your repository, shaped like the rule in the dashboard. Use it in the reconciler, in a test against recorded payloads, and as a check in the receiver.
type FilterRule = { field: string; equals: string }
// Mirror of the rules configured in the sender's dashboard.
// Changing one without the other is a bug; the drift check below enforces it.
export const invoiceWebhookFilter: FilterRule[] = [
{ field: 'to_domain', equals: 'example.com' },
]
function get(obj: unknown, path: string): unknown {
return path.split('.').reduce<any>((o, k) => (o == null ? undefined : o[k]), obj)
}
export function matchesFilter(payload: unknown, rules: FilterRule[]): boolean {
return rules.every((r) => String(get(payload, r.field) ?? '') === r.equals)
}
The field name is illustrative. Use whatever your sender filters on and copy its operators as closely as the docs allow. Where they're vague about case or arrays, make your mirror the stricter of the two, so it leans towards flagging events the sender might have dropped.
Turn filter drift into a failing check
A mirror that quietly diverges from the dashboard is worse than having none. Check it.
If the sender exposes webhook configuration through an API, pull it on a schedule and compare. Event type subscriptions are the easy case. Stripe returns enabled_events on each webhook endpoint, and GitHub returns events on each hook.
import Stripe from 'stripe'
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!)
const expected: Record<string, string[]> = {
'https://api.example.com/webhooks/stripe': [
'invoice.paid',
'invoice.payment_failed',
'customer.subscription.updated',
],
}
export async function checkStripeSubscriptions(): Promise<string[]> {
const problems: string[] = []
const endpoints = await stripe.webhookEndpoints.list({ limit: 100 })
for (const ep of endpoints.data) {
const want = expected[ep.url]
if (!want) continue
const have = new Set(ep.enabled_events)
for (const e of want) {
if (!have.has(e) && !have.has('*')) problems.push(`${ep.url} missing ${e}`)
}
}
return problems
}
Run it daily and page someone when it returns anything. If content filters only exist in a dashboard, you can't automate the comparison, so fall back on process. The rule lives in your repo, a dashboard change gets the same review as a code change, and someone pastes the dashboard state into the pull request. Clunky, yes. Still better than hearing about the rule from a customer.
Filter twice: the sender for volume, you for correctness
The sender-side filter saves you work. You get fewer requests, smaller logs and less of other people's data sitting in your inspection tool. Keep that.
Just don't make the sender's filter responsible for correctness. Have the sender send a superset of what you need, then narrow it again in your receiver with your own predicate. Loose upstream, strict downstream. When the two disagree, your receiver sees an event it would have dropped and can count it. An event the sender dropped can't be counted by anyone.
It's the same reasoning as signature verification at a gateway versus in your handler, from the post on gateway transformations. The layer that sees the raw input should decide little. The layer that owns the business rule decides, and leaves a trace.
Plan limits will push you toward filters
Pricing plays a part too. The same September 27 Emailit update capped webhook endpoints per plan: three on Pay as you go, ten on Pro, a hundred on Business. Other senders cap endpoints as well.
Run out of endpoints and the obvious move is to put several consumers on one endpoint and route by filter. That works until the routing logic sits in two places, the filter rules in the dashboard and the fan-out in your receiver. Then nobody sees the whole picture.
If you have to consolidate, do it onto a receiver you control. One broad endpoint, then your own fan-out with your own rules and metrics. The sender's filter only controls volume. Routing happens on your side.
Also watch plan changes. Emailit's docs say setting a filter on Pay as you go returns a 403. They don't say what happens to existing filters when an account moves to a plan without them. Find that out before the billing change.
Watch for the events you expected
The usual webhook alerts are built on attempts: error rate, retry depth, latency, disabled endpoints. We covered those in the post on webhook health metrics. You need them. By design they can't see filtering.
So add expected volume per event type. For each type you care about, keep a rolling baseline for this hour of the week and alert when arrivals fall well below it. A filter that stops matching shows up as a cliff in one event type while the rest stays flat. An outage drops everything at once. A sender delay comes back as a burst. This looks like neither.
Annotate configuration changes the way you annotate deploys. Every filter edit writes an event to your timeline, so when the cliff appears the cause is sitting right next to it.
Verify the events that do arrive
For the events that get through, the basics still apply. Emailit signs each request with X-Emailit-Signature, a hex HMAC-SHA256 of the X-Emailit-Timestamp value, a dot and the raw body, keyed with the webhook secret. Its example rejects timestamps more than 300 seconds from now.
import { createHmac, timingSafeEqual } from 'node:crypto'
export function verifyEmailit(rawBody: string, headers: Headers, secret: string): boolean {
const ts = headers.get('x-emailit-timestamp')
const sig = headers.get('x-emailit-signature')
if (!ts || !sig) return false
if (Math.abs(Date.now() / 1000 - Number(ts)) > 300) return false
const expected = createHmac('sha256', secret).update(`${ts}.${rawBody}`).digest('hex')
const a = Buffer.from(expected)
const b = Buffer.from(sig)
return a.length === b.length && timingSafeEqual(a, b)
}
There's a catch in a seven-day manual retry window combined with a five-minute timestamp tolerance. Check whether a request re-queued days later arrives with a fresh timestamp. If it doesn't, your verifier rejects every retry. That failure mode is in the post on signature tolerance and retries. Find out before you need the retry button.
Frequently asked questions
Should I avoid sender-side payload filters altogether? No. They cut request volume, compute and the amount of third-party data that lands in your logs, and those are real gains. Use them as a coarse valve, keep a stricter predicate in your own receiver, and make sure every rule in the dashboard also exists in your repository.
Can I recover events that a filter dropped? Not through webhook retries, because a filtered event was never attempted and so never appears in the failed list. If the sender has an events or activity API, you can backfill from there. Otherwise your reconciliation job fetches the current state of the affected objects and you rebuild from that.
How do I tell a filter problem apart from a delivery outage? Look at the shape of the drop. An outage hits every event type at once, and a sender delay ends in a burst. A filter that stops matching takes out one event type, or one slice of one type, while everything else stays at normal volume and the sender reports no failures at all.
Do event type subscriptions need the same treatment as content filters? Yes, though they are easier to manage. Stripe and GitHub both expose the subscribed event list through their APIs, so you can diff it against a list in your repository on a schedule and fail loudly when someone unticks a box.
What should the reconciler do when it finds a gap? Evaluate your copy of the filter rules against the missing object before it raises an alert. If the object would not have matched, the alert should say so. That sends the ticket to whoever owns the integration settings instead of to the person debugging the receiver.