Model or dataset
prehisle/relay-pulse avatar
prehisle/relay-pulse

Relay Pulse spends one token per probe, and its board field means two things

An enterprise-grade availability monitoring system for LLM relay/proxy services, tracking service status in real time with a visualization dashboard.

1,108 stars93 forksGoMIT

At a glance

What is it?
Relay Pulse is a Go service that monitors LLM API relay providers by actually calling them, because an HTTP 200 with an empty body counts as nothing. It costs about 30,000 tokens a day per monitored service, keeps keys local, and publishes a hosted board showing which third-party relays answer. The parts worth reading are the sliding window, the overloaded status field, and the disclaimer.
Who is it for?
Relay Pulse suits someone who has bought access to a third-party LLM relay and needs to know whether it is genuinely answering or just returning empty 200s, and who is willing to hold a real API key for every service on the board. It does not suit you as evidence about a provider's business, since the page says the data can be wrong because of network fluctuation, regional differences and cache delay, and disclaims any judgement about compliance, legality or reputation.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 5 days ago.
What is it written in?
Mainly Go, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 21, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • prehisle/relay-pulse1,108 ★ · +5
Star history
Repository2026-09-132026-11-21
prehisle/relay-pulse1.1k1.1k

5 Stars in the last 69 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The probe buys one output token to prove the model is alive

The premise is a specific failure mode. Traditional monitors such as Uptime Kuma watch HTTP connectivity, but in the relay market a service can answer 200 while returning empty content or an error code, and a status page built on reachability will call that healthy. Relay Pulse makes periodic API calls that consume real tokens and then validates the response content, counting a service as available only when the model actually emitted output. The cost is quoted on the page so you can decide: a probe sets the output limit to one token and uses roughly 20 input tokens and 1 output token, running once a minute by default, which works out to about 30,000 tokens a day per monitored service. On the privacy side, configuration and keys stay in the local or self-hosted environment and monitoring data is not sent back.

One field name, two meanings, in two endpoints

There is a naming trap in the response schema. In the status query endpoint, `board` is a channel-level activity collapse with only two possible values. A channel is `hot` when it still has active monitors, which includes monitors configured as either hot or secondary, and `cold` when everything under that channel, excluding disabled entries, is cold. That is not the same field as the one the main status endpoint returns per monitor, which has three values, hot, secondary and cold. A client that reads the two interchangeably will produce a confidently wrong board. The batch query example is also cut off mid-JSON, ending partway through a channel value with the closing braces missing, and the page notes that the API reference chapter is still being assembled and the endpoint examples are the current authoritative source.

The 24-hour figure is a sliding window, so it moves while you read it

Every status response is computed from the moment you ask for it. The 24-hour period returns data counted back 24 hours from the current instant, so the time base differs on every request and the bucket boundaries shift slightly each time. The consequence the page spells out is that provider rankings always reflect the most recent 24 hours, and if you want fixed-point data for an integration you should sample at a fixed frequency, such as on the hour. The same service exposes 24 hour, 7 day and 30 day windows as heatmaps in the web interface, and the plain status endpoint takes the period and a board filter directly:

bash
curl http://localhost:8080/api/status
curl http://localhost:8080/api/status?period=7d
curl http://localhost:8080/api/status?board=hot

There is also a health endpoint for container probes and a version endpoint, and a status query endpoint aimed at subscription checks, which takes a provider, a provider with a service, or a full provider, service and channel triple.

The Go module is called monitor, and SQLite is the CGO-free driver

The module declaration is a plain `monitor`, not the project name, so the import path inside the tree carries a generic name that tells you nothing about which repository it came from. The declared floor is Go 1.25.0, and the storage driver is the pure Go SQLite implementation rather than a cgo one, which is what lets the project ship a small static image. Compression is handled in layers: a gzip middleware, a Brotli library, and a general compression package, so clients can pick their encoding. CORS middleware is present with a configurable origin list, and the example environment file marks that list as development-only. PostgreSQL access goes through the standard driver. One small spread to note: the tech stack section says Go 1.25 or newer while the container build uses a newer Go toolchain image, so the tested floor and the shipped compiler are not the same thing.

A build stage numbered 1.5 reuses the frontend from CI

The Dockerfile has three frontend paths, which is unusual enough to be worth reading. A normal Node stage builds the assets, and a stage built `FROM scratch` holds an already-built dist directory so continuous integration can skip the Node build entirely. Which one gets used is chosen by a build argument that defaults to the builder, so the same Dockerfile serves both a local build and a pipeline that already has artifacts. The Go stage then clears the embed directory before copying the assets in, explicitly to avoid a nested dist inside dist, and verifies a key file exists afterwards. Two details that affect your build rather than the design: the frontend install uses the legacy peer dependency flag, which relaxes version checking, and the Go proxy list leads with a regional mirror before the public one and the direct fallback, so a build outside that region resolves through the public proxy after trying the first.

The database lives in a separate volume so the binary can update

The compose file's comments explain a failure mode rather than just listing settings. The config directory is mounted at `/config` and a directory mount is used specifically because it supports hot reload, which is the fsnotify-based feature that lets you edit configuration without a restart. The database goes in a named volume at `/data` with its path set by an environment variable, and the stated reason for keeping it out of the application directory is to avoid overwriting `/app` and ending up with a binary that does not update. Template files are baked into the image and symlinked into the config directory at startup, so you do not have to mount them unless you want to customise them. Two storage profiles are documented, SQLite for a single machine and a Postgres service started alongside a second monitor service for Kubernetes, and the port mapping note mentions that binding port 80 for a CDN in front needs root.

The public board carries prices, and there is a build flag to hide them

The hosted instance at the project's own domain is a board of third-party relay providers, and two configuration surfaces show it is also a commercial surface. Monitor entries carry a sponsor field and an optional sponsor level drawn from a six-rung ladder, and the frontend build accepts an argument that hides the price column in the public lists and cards at build time, which suggests the prices are shown by default. The disclaimer is the part to read carefully. It says the status and trends come from automated technical probing and can contain errors from network fluctuation, regional differences and cache delay, that the results are for reference and do not judge any service's compliance, legality, qualifications or commercial reputation, and that the author takes no responsibility for the content, reliability, reputation or fund safety of third-party providers displayed on any site built with the software, including the hosted one. Users bear that risk themselves. There is a correction route through a dedicated issue template with a 48 hour response target, subject to holiday delay.

Editorial conclusion

Relay Pulse suits someone who has bought access to a third-party LLM relay and needs to know whether it is genuinely answering or just returning empty 200s, and who is willing to hold a real API key for every service on the board. It does not suit you as evidence about a provider's business, since the page says the data can be wrong because of network fluctuation, regional differences and cache delay, and disclaims any judgement about compliance, legality or reputation. Before you rely on a number, sample on a fixed schedule rather than reading the live endpoint, because the 24-hour figure is a sliding window; and treat a channel marked hot as activity, not quality, since it only means monitors are still configured against it.

Frequently asked questions

How does Relay Pulse check whether an LLM relay is really working?

It makes periodic API calls that consume real tokens and then validates the response content, counting a service as available only when the model actually produced output. That is aimed at the case the page describes, where a relay returns HTTP 200 with empty content or an error code, which a reachability-only monitor would record as healthy.

What does it cost to monitor an LLM service with Relay Pulse?

The page puts a probe at an output limit of one token, roughly 20 input tokens and 1 output token, running once a minute by default, which is about 30,000 tokens a day per monitored service. Configuration and keys stay in the local or self-hosted environment, and monitoring data is not sent back.

What does the board field mean in the Relay Pulse API?

It depends on the endpoint. In the status query response it is a channel-level activity collapse with only hot or cold, where hot means the channel still has active monitors including ones configured as hot or secondary. In the main status endpoint the same field name has three values per monitor, hot, secondary and cold, and the page explicitly warns that the two differ.

Why do Relay Pulse availability numbers change between requests?

The API uses a sliding window, so a 24 hour period counts back from the current moment and the bucket boundaries shift slightly on every request. Provider rankings therefore always reflect the most recent 24 hours, and the page suggests sampling at a fixed frequency, such as on the hour, if you need fixed-point data for an integration.

Does Relay Pulse vouch for the relay services it monitors?

No, and the page is explicit. It says the data comes from automated probing that can be wrong because of network fluctuation, regional differences and cache delay, that results are for reference only and are not a judgement about any service's compliance, legality, qualifications or commercial reputation, and that users bear the risk of interacting with third-party providers themselves.

Official sources

  1. License: MIT
  2. prehisle/relay-pulse on GitHub
  3. Project website
  4. README
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/prehisle-relay-pulse.svg)](https://hysenlabs.com/projects/prehisle-relay-pulse)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/prehisle-relay-pulse.svg)](https://hysenlabs.com/projects/prehisle-relay-pulse)

Was this useful?