Skip to content

Alertmanager Route Tester · Observability

Alertmanager route tester — see which receiver an alert hits before it pages anyone.

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.

Runs in your browser — nothing you paste leaves this page. How we prove that

Runs in your browser No signup Routing-accurate Updated Jul 29, 2026

Alertmanager Route Tester playground

alertmanager.yml · route

Paste a route tree or full config — runs entirely in your browser.

alert labels · key=value

One label per line, e.g. severity=critical.

Tip: press Esc to release keyboard focus from an editor.

Matched receivers

Load an example or paste a route tree and an alert’s labels, then run to see which receiver(s) the alert reaches.

The Gap

A routing tree is code you can’t step through.

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.

See the routing rules it models, or try the live playground above.

The Pipeline

How this amtool routes test online works.

Five deterministic steps test your Alertmanager route tree against alert labels end-to-end on every evaluation — all inside your browser tab, so you can test Alertmanager routing without installing amtool.

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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 routing.

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 }

Fix

route
# continue: true lets BOTH fire
routes:
  - receiver: all-critical-audit
    matchers: ['severity="critical"']
    continue: true
  - receiver: team-backend
    match: { team: backend }

Regexes are fully anchored

matchers

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']

The full routing example in the Alertmanager docs — a root receiver with team-X / team-Y / database children — loads as the first example in the playground.

Next Step

Test the rest of your alerting pipeline.

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.

route.yml
# 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.

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.

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.

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.

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.

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.

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.

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.

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.

39 free tools, every one offline-capable — opscanopy.com works with no signup and nothing uploaded.

Related tools: the Prometheus relabel tester and Loki alert rule tester. Browse the full tools directory.

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.