This online Alertmanager route tester lets you paste an
Alertmanager routing tree and a
sample alert’s labels, then walks the tree the way Alertmanager does: matched receiver(s),
the route-path breadcrumb, continue
behaviour, and the effective grouping. Find which receiver an alert matches instantly, in your
browser.
The Gap
Why an alert reaches the wrong Alertmanager receiver.
An Alertmanager route is a
decision tree, and like any tree it is easy to get subtly wrong: a broad rule placed
above a specific one silently shadows it, a missing
continue stops the on-call team
from ever being paged, and an un-anchored regex quietly matches nothing. So when you need
to answer which Alertmanager receiver matches a given alert,
guessing is expensive.
The usual way to find out is to fire a real alert and watch where it lands — slow, noisy, and risky on a live setup. Alertmanager’s
own routing tree editor helps, but a routing tree editor that’s not matching the
routes you expect still leaves you to reason about
match vs
match_re vs
matchers, first-match ordering,
and inheritance in your head. See the official
route reference and
matcher syntax.
This Alertmanager routing tree tester does the walk for you: a route matcher tester that
takes the tree and a label set and reports the receiver(s) an alert reaches with the full
path and effective grouping. It works as an Alertmanager route debugger and a
browser-based way to test your Alertmanager routing config — nothing installed,
nothing sent, nothing uploaded.
Five deterministic steps take your route tree and an alert's labels and resolve the receiver end-to-end on every evaluation — all inside your browser tab, with no amtool and no running Alertmanager.
01
Parse the config.
Your YAML is parsed and the route tree is resolved — a full alertmanager.yml uses its route: block, a bare route object is taken as the root. Parse errors are reported, not thrown.
02
Read the labels.
The alert's key=value lines become a label set. A label that is absent is treated as the empty string, exactly as Alertmanager compares it.
03
Walk the tree.
Starting at the always-matching root, child routes are evaluated in order. The alert descends into the first matching child; a continue: true keeps later siblings in play.
04
Resolve inheritance.
At each terminal match, the receiver and the grouping/timer fields are resolved from the nearest ancestor that set them — the values Alertmanager would actually use.
05
Show the receivers.
Every receiver the alert reaches is listed with its route-path breadcrumb, a continue tag where relevant, and the effective group_by.
Routing Rules
The 4 rules that decide which receiver an alert matches.
The tester reproduces these Alertmanager semantics exactly, so
you can test Alertmanager matchers against labels online — for example, check the
receiver an alert with a severity=critical
label reaches. Each rule below shows the trap and the fix.
First match wins (unless continue)
order
Within a matched route, children are evaluated top to bottom. The alert takes the FIRST matching sibling and stops — later siblings are skipped unless continue: true is set.
Trap
route
# Order matters — the broad rule above shadows the specific one
routes:
- receiver: catch-all # matches everything below
matchers: ['severity=~".*"']
- receiver: db-pager # NEVER reached
match: { service: database }
Fix
route
# Specific first, broad last — or use continue
routes:
- receiver: db-pager
match: { service: database }
- receiver: catch-all
matchers: ['severity=~".*"']
continue: true → multiple receivers
fan-out
A matched route with continue: true does not stop the sibling scan, so the alert can also land in a later route. Use it to mirror critical alerts to an audit or paging receiver.
Trap
route
# Without continue, only the audit receiver fires —
# the owning team is never paged
routes:
- receiver: all-critical-audit
matchers: ['severity="critical"']
- receiver: team-backend
match: { team: backend }
Alertmanager wraps every match_re and =~/!~ pattern as ^(?:…)$. A partial pattern never matches the whole value — a frequent cause of "my route is not matching".
Trap
matchers
# 'staging' only matches the value EXACTLY "staging"
matchers:
- env=~"staging" # env=staging-eu does NOT match
Fix
matchers
# Cover the rest of the value explicitly
matchers:
- env=~"staging-.*" # env=staging-eu matches
Grouping is inherited down the tree
grouping
group_by, group_wait, group_interval, and repeat_interval flow from a parent to any child that does not set its own. The leaf you see may not be the grouping that applies.
Trap
route
# This leaf has no group_by of its own…
route:
group_by: ['alertname', 'cluster']
routes:
- receiver: db-pager
match: { service: database }
# …so it INHERITS [alertname, cluster]
Fix
route
# Override only where the subtree needs it
route:
group_by: ['alertname', 'cluster']
routes:
- receiver: db-pager
match: { service: database }
group_by: ['alertname', 'cluster', 'database']
Routing is the last hop. Get the labels right at the source — relabel them as they
are scraped with the Prometheus Relabel Tester, and prove
your alert rules fire with the Loki Alert Rule Tester
— so the route tree above has the right labels to work with.
# labels in → route walk → receiver out
labels: { team: backend, severity: critical }
route: first-match + continue
receiver: team-backend, all-critical-audit
FAQ
Questions, answered.
Tap a question to expand the answer.
How do I test which receiver an alert matches in Alertmanager?
Paste your route tree (or a full alertmanager.yml — only its route block is read) and a sample alert's labels into this online Alertmanager route tester. It reproduces Alertmanager's routing walk in your browser and shows which receiver or receivers the alert would reach, the exact route-path breadcrumb from the root down to the matched node, whether a continue: true caused multiple receivers to fire, and the effective group_by after inheritance. It is a dry-run of dispatch without sending a single notification, so you can find which receiver an alert matches in Alertmanager before it pages anyone.
What does amtool config routes test do?
amtool config routes test resolves your alertmanager.yml route tree against a set of label matchers and prints the receivers an alert would hit, mirroring how the running Alertmanager dispatches. This page is a browser-based amtool routes test online: it does the same routing-tree walk client-side, so you can test Alertmanager routing without installing amtool or pointing it at a live config. Paste the tree, paste the labels, and read off the matched receivers and path.
Why is my Alertmanager alert going to the wrong receiver?
Almost always it is route order, an un-anchored regex, or a missing continue. Within a matched route, siblings are evaluated top to bottom and only the first match is taken — so a broad rule placed above a specific one silently shadows it. match_re and =~ patterns are fully anchored, so env=~"staging" never matches staging-eu. Use this Alertmanager route debugger to walk the tree against the exact labels and see which node actually matched, which makes the answer to "why is my Alertmanager alert going to the wrong receiver" obvious.
How does the continue flag work in Alertmanager routing?
By default, once an alert matches a route in a sibling list, Alertmanager stops scanning the rest of that list. Setting continue: true on a matched route tells Alertmanager to keep evaluating the later siblings, so the alert can land in more than one receiver — the usual way teams mirror every critical alert to an audit or paging receiver while still routing it to the owning team. As a continue route tester, this tool tags each receiver a continue: true produces so you can see exactly which matches came from falling through.
Can an alert match more than one Alertmanager receiver?
Yes — but only when continue: true is set on a matched route. Without it, the first matching sibling wins and the scan stops, so an alert reaches exactly one receiver per route list. With continue: true, the alert keeps descending through later siblings and can fan out to several receivers. This Alertmanager continue true routing tester shows every receiver in the order they fire, so you can confirm the fan-out is what you intended.
How do I test Alertmanager routing without a running instance?
You do not need a running Alertmanager, and you do not need amtool. This is a free online Alertmanager route tester with no install: everything runs 100% client-side inside your browser tab. Paste your route tree and alert labels to test your Alertmanager routing config and simulate Alertmanager alert routing in the browser. Nothing is uploaded and there is no signup, so you can safely paste internal receiver names and private team labels.
Why does the Prometheus routing tree editor show the wrong route?
The Prometheus routing tree editor visualises the tree but still leaves you to reason about match vs match_re vs matchers, first-match ordering, and inheritance in your head — so it can look right while an alert routes somewhere else. If the routing tree editor is not matching the routes you expect, use this as an alternative: test Alertmanager matchers against labels online and the tester walks the real semantics and highlights the matched path, rather than just drawing the tree.
How does Alertmanager decide which route matches first?
Every alert enters the root route, which is the catch-all. Within a matched route, child routes are evaluated top to bottom, and the alert descends into the first child whose matchers all hold — for example the first node that requires a severity="critical" label. It keeps descending through that subtree; if a matched route has no matching child, that route is the terminal match and its receiver fires. The rule people get wrong is order plus first-match: only the first matching sibling is taken unless continue: true is set.
More free, private DevOps tools.
The Alertmanager Route Tester is one tool in
OpsCanopy — a growing canopy of browser-based validators,
converters and testers that never touch a server.
Not affiliated with, endorsed by, or sponsored by the
Prometheus project or the
Cloud Native Computing Foundation.
Prometheus and Alertmanager are used
here only descriptively, to identify the configuration format this tool checks.