monit.rs · Zenofex LLC
Eleven of the 44 public APIs we score shipped zero breaking changes in 90 days, and four have published a byte-identical OpenAPI document since July — verified by re-fetching and comparing SHA-256. The more useful result: surface size predicts almost nothing. GitLab carries 1,150 operations,…
Four public APIs have not changed a byte since July, and GitLab shipped 12 spec revisions without breaking anything
TL;DR: Last week we published the ugly half of our data — 62% of the breaking changes we counted came from vendors whose specs were flapping. This is the other half. Eleven of the 44 public APIs we score shipped zero breaking changes in 90 days. Four of them — Slack, Spotify, DocuSign and Replicate — have published a byte-identical OpenAPI document since July, which we verified by re-fetching each one and comparing SHA-256 against our stored snapshot. But the more useful result is that surface size and change rate predict almost nothing: GitLab carries 1,150 operations, shipped 12 spec revisions in 90 days, and scored 95.
See it live: all 47 ranked, most stable first. No signup. Atom feed, or one per vendor.
We published the critical report first on purpose. A tool that only ever names the worst offender is a tool with an incentive to find one, and the first thing we found when we read our own bottom-of-the-table by hand was that our metric was overstating it by 59%. That correction shipped the same day.
So the praise comes after the criticism and after the fix, measured on the corrected metric (v3). All figures below are counted vendor actions per 100 API operations over the 90 days ending 8 November 2026.
Lumping these together would be the easy mistake. "Zero breaking changes" means something different depending on whether the vendor changed anything at all.
Changes regularly, never breakingly. These shipped spec revisions in the window and not one of them broke a consumer:
Loops shipped ten revisions in 90 days and broke nothing. That is the hardest version of this result and the one worth respecting: staying still is easy, moving carefully is not.
Has not changed at all. These four produced no diff because the published document is identical to the one we first captured:
We did not take our own word for this. Our snapshot table deduplicates by SHA-256, so an unchanging spec and an untracked one look identical in the data — both produce no entries. To tell them apart we re-fetched all four specs today and compared hashes against the stored snapshot. All four matched exactly. lastfetchat for every one of them is today, so these are live, weekly-fetched, and genuinely static.
That check is not academic. We nearly filed this as a scoring bug on the strength of the entry counts alone, which would have stripped a correct rating from four vendors who earned it.
A static spec is a weaker claim than a careful one, though, and we will say so: it means the published document has not moved. It does not prove the API behind it has not.
The result that actually matters: size does not predict breakage
The intuition is that a big, fast-moving API breaks more. It does not hold.
GitLab has roughly 15 times Algolia's surface area and shipped more revisions than it, and still sits at 0.17 breaking changes per 100 operations. Jira shipped 15 revisions in 90 days — more than any vendor in the zero group — at 0.48.
Compare that with the bottom of the board, where Supabase (Data) sits at 69.41 across a 170-operation surface. Small and volatile is entirely possible; large and careful is entirely possible. The variable is not size. It is whether the vendor treats its published contract as a contract.
The tail gets the attention, and the tail is loud: the mean rate across 44 scored vendors is 12.1 breaking changes per 100 operations, which sounds alarming. The median is 2.77 — and that gap between mean and median is the whole shape of this dataset. 22 of 44 vendors sit below the median. 16 are under 1.0. 11 are at zero. A handful of outliers drag the average four times above the typical vendor, and if you integrate against a randomly chosen public API your realistic expectation is a couple of breaking changes per 100 operations per quarter — not the dozens the headline numbers imply.
The score is already public, it updates weekly, and the badge is embeddable:
Swap in your own slug — the badges page lists all 47 and the SVG is shields.io-compatible. We do not ask for anything in return and there is nothing to sign up for. If you think a number is wrong, the method is below and every underlying change is listed on your vendor page; tell us and we will check it by hand, which is how the last correction happened.
Weekly snapshots of each vendor's published OpenAPI document, diffed against the previous snapshot, following $ref into shared components.schemas. A breaking change is one that can break an existing integration: a removed endpoint or field, a tightened constraint, a changed response type, a newly required request property.
Counting, per methodology v3: within one revision a change counts once per kind as the smaller of distinct operations and distinct messages, and it counts only at the revision where it first appeared, so a regenerated spec reporting the same change weekly is not charged twice.
Three of the 47 are unscored and named as such on the leaderboard rather than silently dropped: SendGrid Mail, Notion and Twilio Lookups all have too few tracked operations for a per-100 rate to mean anything.
What 0.0 does not mean. It is a measurement of a published OpenAPI document, not of an API's runtime behaviour. A vendor can ship a breaking change without touching its spec — removing an undocumented field, tightening a rate limit, changing an error body that was never described. We would not see any of that. It also covers 90 days, which is a quarter, not a track record.
Window: the 90 days ending 8 November 2026. Live hash verification of the four static specs performed 8 November 2026.
The figures on this page come from the same diff engine monit.rs runs against customer endpoints. Point it at your own API and it works the same way: it learns each response schema by example, diffs every subsequent response against that baseline, and alerts you when a breaking change ships. The free tier is 3 endpoints with the full feature set and no card required. Start monitoring free.
monit.rs compares observed response fields and types with a learned baseline. Run OpenAPI contract checks against the latest stored response when you want to compare the implementation with a declared contract.
See the difference when a field disappears or changes type. Optional AI summaries suggest possible causes and next steps; review the evidence before accepting a new baseline.
monit.rs also runs a public changelog of 47+ well-known API vendors (Stripe, GitHub, OpenAI, Cloudflare, Datadog, PostHog, Vercel, Supabase, and 39 more). Every detected OpenAPI change is published at /changelog with per-vendor RSS feeds, stability badges, and side-by-side comparison pages.
See how we compare with existing monitors: vs Pingdom · vs Checkly · vs Uptime Robot · vs Statuspage.io · vs Bump.sh · vs Optic · vs Postman Monitors
3 endpoints. Full features. No credit card required.