Most services fail by stopping. Vault fails by starting. A node reboots for a kernel update, the process comes back, port 8200 is listening, the load balancer marks it healthy on a TCP check, and nothing works: Vault's documentation is blunt that a server starts in a sealed state and stays unsealed only until it restarts. Without auto-unseal, every application that needs a secret begins failing as its leases expire, one by one, over the following hours, and the on-call engineer gets paged for a database connection error in an application three hops away from the actual cause.
Vault's authors knew this, which is why /v1/sys/health is one of the best-designed health endpoints in common use: it tells you the node's exact state in the HTTP status code and lets you choose the codes. This guide turns that into a set of external monitors for Vault and for OpenBao, the open-source fork that inherited the endpoint. Exact expected status codes, custom headers, and certificate monitoring are on every CronAlert plan; keyword assertions and heartbeats are Pro ($5/month) and are marked. The examples use port 8200 and a three-node Raft cluster behind vault.example.com.
The status codes
| Code | Node state | Override parameter |
|---|---|---|
| 200 | initialized, unsealed, and active | activecode |
| 429 | unsealed and standby | standbycode; standbyok=true makes it 200 |
| 472 | disaster recovery secondary (active or standby within it) | drsecondarycode |
| 473 | performance standby | performancestandbycode; perfstandbyok=true makes it 200 |
| 474 | standby that cannot connect to the active node | haunhealthycode |
| 501 | not initialized | uninitcode |
| 503 | sealed | sealedcode |
| 530 | removed from the cluster | removedcode |
Both GET and HEAD are supported, and the JSON body carries initialized, sealed, standby, performance_standby, the replication modes, version, cluster_name, server_time_utc, and on standbys ha_connection_healthy. The documentation adds one caveat worth knowing: during cluster instability a node may briefly return 429 even if it is part of a DR secondary or a performance standby. CronAlert lets you set any exact expected status from 100 to 599 on a monitor, which is what makes this endpoint so useful: you can assert the state you expect, not just "something answered."
Step 1: the cluster address must be 200
Create an HTTP monitor on https://vault.example.com:8200/v1/sys/health, the address your clients use, with expected status 200 and a 10-second timeout. Through a load balancer that routes to the active node (or with request forwarding, where standbys forward client requests to the leader but still answer /sys/health as themselves, so route the health check to the active node or add standbyok=true), a 200 means there is an initialized, unsealed, active node serving clients. Anything else is an outage: 503 is the sealed-after-restart case, 501 means a fresh node that was never initialized was put into rotation, 474 means the standby answering has lost the leader, and a connection error means the whole cluster or the balancer is gone.
The interval is 3 minutes on Free and 1 minute on Pro. Send the alert to a channel that does not depend on Vault: if your Slack webhook or SMTP credentials are themselves stored in Vault and fetched at send time, a sealed Vault silences its own alert. Push notifications, or a channel configured with a static credential, break that loop.
Step 2: one monitor per node, with the right expected status
The cluster address tells you the service is up. It does not tell you that you have lost two of three nodes and are one failure from losing quorum. Add a monitor per node, each with the status that node should return:
| Monitor | URL | Expected | Red means |
|---|---|---|---|
| vault-1 (active) | https://vault-1.example.com:8200/v1/sys/health | 200 | sealed (503), lost leadership (429), down |
| vault-2 (standby) | https://vault-2.example.com:8200/v1/sys/health | 429 | sealed (503), cannot reach active (474), became active (200), down |
| vault-3 (standby) | … | 429 | same |
The catch is that leadership moves: after a failover the former standby answers 200 and the monitor expecting 429 goes red, which is correct in the sense that something changed, and annoying if failovers are routine for you. Two ways out. Add ?standbyok=true&perfstandbyok=true to each node's URL so every healthy unsealed node answers 200 regardless of role, and let the cluster-address monitor from step 1 be the only one that cares about leadership. Or, on Pro, keep the role assertion in a keyword monitor instead of the status: expect 200 with standbyok, and assert contains "sealed":false, which is the one fact you care about per node. Most teams land on the first option.
A per-node monitor needs the node reachable from outside, which many Vault clusters are not. For nodes on a private network, use TCP monitors on 8200 if the hosts have public addresses, or the heartbeat pattern in step 5 from a host inside the network.
Step 3: seal status and leader as keyword checks (Pro)
GET /v1/sys/seal-status is documented as unauthenticated and returns type, initialized, sealed, t and n (the Shamir threshold and share count), progress, version, cluster_name, and storage_type. A monitor on it with contains "sealed":false is a plain-English version of the step 1 check and a better one to show on an internal status page, since "sealed" is the word your team will search for. GET /v1/sys/leader returns ha_enabled, is_self, and leader_address; a monitor on the cluster address asserting contains "ha_enabled":true catches a node that lost its HA configuration, and not_contains "leader_address":"" catches a cluster with no leader.
These endpoints leak the version, cluster name, and addresses to anyone who can reach them. On an internet-facing listener, set redact_version, redact_cluster_name, and redact_addresses to true; the health and seal-status codes still work, and the monitors above that assert on sealed and ha_enabled are unaffected. Only a leader_address assertion needs the unredacted value.
Step 4: a token that watches its own expiry (Pro)
Anything beyond the three unauthenticated endpoints needs a token, and the classic monitoring failure is a monitoring token that expired six months ago while the check it protected quietly went green or quietly stopped. Create a token with a minimal policy (read on auth/token/lookup-self and, if you want metrics, sys/metrics) and a long but finite TTL, then run a cron job that checks its own remaining life:
# hourly: the monitoring token must have more than 7 days left, and Vault must answer an authenticated call
0 * * * * TTL=$(curl -fsS --max-time 10 -H "X-Vault-Token: $VAULT_MON_TOKEN" \
https://vault.example.com:8200/v1/auth/token/lookup-self | jq .data.ttl) \
&& [ "$TTL" -gt 604800 ] \
&& curl -fsS --max-time 10 --retry 3 https://cronalert.com/api/heartbeat/YOUR-TOKEN Create a heartbeat monitor with an expected interval of 1 hour and a grace of 30 minutes. The ping stops a week before the token expires, which is a week of warning to renew it, and it also stops if Vault stops answering authenticated requests, which is a different failure from the health endpoint (a sealed Vault fails both; a Vault with a broken auth backend fails only this one). Put the token in the cron host's environment or a file with tight permissions, never in a CronAlert monitor's headers: a monitor's custom headers are visible to your team, and a Vault token is exactly the credential you do not want copied around. Cron job heartbeats covers the pattern.
Step 5: metrics and private clusters
GET /v1/sys/metrics?format=prometheus needs a token unless the listener's telemetry stanza sets unauthenticated_metrics_access = true, and the documentation warns that only the active node responds with data; followers ignore metric requests, which typically results in a timeout. So a metrics check belongs on the cluster address, from a script with a token, and the same script can gate a heartbeat on whatever you care about (lease counts, request latency). If you already run Prometheus, scrape there and use a watchdog heartbeat so you know Prometheus itself is alive.
For a Vault that is not reachable from the internet, run the health checks from a host inside the network and report with a heartbeat: curl -fsS -o /dev/null https://vault.example.com:8200/v1/sys/health && curl …heartbeat. The -f flag fails on any non-2xx, so a 503 or 429 skips the ping; add ?standbyok=true if the check may land on a standby. Monitoring internal tools covers the approach.
Step 6: snapshots (Pro)
With Integrated Storage, GET /v1/sys/storage/raft/snapshot returns a snapshot of the Raft state as binary data to redirect to a file, authenticated with a token; the documentation notes it is unavailable if Raft is used only for HA storage. Automated snapshots with their own status endpoint are a Vault Enterprise feature, so on open-source Vault and on OpenBao the backup is a cron job:
# /etc/cron.daily/vault-snapshot
set -euo pipefail
DEST=/srv/backups/vault/$(date +%F).snap
curl -fsS --max-time 120 -H "X-Vault-Token: $VAULT_SNAPSHOT_TOKEN" \
https://vault.example.com:8200/v1/sys/storage/raft/snapshot -o "$DEST"
[ -s "$DEST" ] # non-empty or fail
# ship it off the host: rclone copy "$DEST" remote:vault/ ...
curl -fsS --max-time 10 --retry 3 https://cronalert.com/api/heartbeat/YOUR-TOKEN Heartbeat expected interval 1 day, grace a few hours. The snapshot token needs the policy for that path and should be separate from the lookup-self token in step 4; give it the same self-expiry check. Remember that a Raft snapshot is useless without the unseal keys or the auto-unseal KMS key, so the restore runbook, not the snapshot job, is where those live. Monitoring backups covers restore testing, which for Vault means restoring into a scratch cluster and reading one secret.
Certificates
Vault assumes TLS by default, and every client validates the certificate on 8200. An expired certificate is a total outage that looks, from the application side, like every secret fetch failing at once. SSL monitoring is included with every HTTP monitor on every plan, so the step 1 and step 2 monitors already alert before the certificate on each address expires. If the cluster uses an internal CA, the HTTP monitors will report a certificate error, since CronAlert's checks validate against public roots; in that case use the inside-the-network heartbeat from step 5 with curl --cacert, and monitor the public-facing certificate on whatever terminates TLS in front.
OpenBao
OpenBao forked from Vault and keeps the same API surface for these endpoints: /v1/sys/health, /v1/sys/seal-status, /v1/sys/leader, token lookup, and the Raft snapshot path, on the same default port. Its seal documentation says the same thing about restarts (the server starts sealed and stays unsealed until it is restarted) and lists its own auto-unseal providers, including cloud KMS services, PKCS#11, Transit, and a static key option that Vault does not have; from 2.6 many providers ship as external plugins. Confirm the exact status codes against your OpenBao version with curl -i before setting expected codes, since the project may diverge over time, and then every step above applies unchanged.
Reading an alert
| Alert | Likely cause | First thing to check |
|---|---|---|
| Cluster address: expected 200, got 503 | Sealed, almost always after a restart without auto-unseal | vault status; unseal, then find out why it restarted |
| Expected 200, got 501 | A never-initialized node is serving the address | Which node the balancer sent you to; initialized in the body |
| Expected 200, got 474 | Standby answering, cannot reach the active node | Leader election; network between nodes on 8201 |
| Expected 200, got 429 | Balancer routed to a standby without standbyok | Balancer health-check routing; add standbyok=true |
| Node monitor expected 429, got 200 | Failover: this node is now active | Check the old leader's monitor; switch to standbyok if this is routine |
| Node monitor: expected 429, got 530 | Node removed from the cluster | vault operator raft list-peers |
| Connection error or timeout | Process, host, or network down | Host; systemctl status vault |
| Token heartbeat overdue | Monitoring token under 7 days left, or auth backend broken while health is green | Renew the token; Vault audit log |
| Snapshot heartbeat overdue | Cron, token, or disk | Run the script by hand |
| Certificate alert | Renewal stopped | Whatever issues the 8200 certificate |
Frequently asked questions
Should I just set standbyok=true everywhere?
On the cluster address, yes if your balancer may route health checks to standbys; on per-node monitors, yes if failovers are routine and you do not want a page for them. Keep at least one check that distinguishes "an active node exists" from "nodes are unsealed": the cluster-address monitor without standbyok, or a /sys/leader keyword check.
Can I monitor /sys/health with HEAD to keep logs quiet?
Yes, HEAD is documented alongside GET and returns the same status code. You lose the body, so keyword assertions need GET.
Is a 1-minute check too much for Vault?
No. /sys/health is designed for load balancers that poll it every few seconds. The authenticated checks in this guide run hourly or daily from cron.
Which parts are free?
The cluster-address and per-node monitors with exact expected status codes, TCP checks, and certificate monitoring are free. The seal-status and leader keyword assertions and the token, inside-network, and snapshot heartbeats need Pro at $5/month.
Get started
One free monitor on the cluster address expecting 200 turns "Vault is sealed" from a slow cascade of application errors into a single alert one interval after the reboot. Create a free CronAlert account, add it, then add one monitor per node. Related reading: monitoring Keycloak and authentik, the other service whose outage breaks everything behind it; monitoring Vaultwarden, a different vault with a different /alive; Kubernetes uptime monitoring for Vault running in-cluster; exact status codes and inverse monitors; and HTTP status codes for monitoring.