AWS Builder Center

Your API Just Broke Your Production. It Didn't Even Send an Email.

We've all been there. A payment provider "simplifies" their auth flow. A data platform quietly deprecates an endpoint. Somewhere in a changelog nobody reads, a response shape shifts from an object to an array. Then, days or weeks later, your CI fails or worse, your production traffic finds out first

This is the story behind APISentry.
The problem nobody's solving
We've gotten really good at managing dependency risk on the package side. Tools like Dependabot and Renovate watch your package.json or requirements.txt, and the moment a library ships a new version, you get a pull request. It's boring, reliable, and it works.
But there's a blind spot: third-party APIs. The REST endpoint your payment integration hits every day. The auth flow your app depends on. Nobody versions these the way packages are versioned. A provider can change a response shape, deprecate a field, or "simplify" an entire auth flow and the only signal might be a paragraph buried in a changelog, or nothing at all.
A meaningful share of unplanned production incidents trace back to exactly this: an external API changing underneath a team without anyone noticing in time.
What APISentry actually does
APISentry treats API contracts the way Dependabot treats package versions. It watches the third-party APIs your codebase depends on, detects when something changes that could break your integration, and with your review writes the fix, commits it, and opens a real pull request.
Not every provider gives you the same signal to work with, so detection works in layers:
Manual scan text paste in raw changelog text and trigger a scan directly. Docs page diff when there's no changelog at all, APISentry snapshots a provider's documentation page using a real headless browser (so even JavaScript-rendered docs get seen), diffs it against the last snapshot, and filters out noise like timestamps and cookie banners before comparing.
Once there's candidate change text, it gets classified two ways. If a Gemini API key is configured, Gemini reads the text for meaning so something like "we simplified the auth flow" gets flagged as breaking even without an obvious trigger word like "deprecated." If not, a zero-dependency heuristic keyword matcher steps in as a fallback. Every detected change records both where it came from and how it was classified, so you always know whether you're looking at a high-confidence AI read or a keyword-matched guess.
From detection to a real pull request
Detecting a change is only half the job — the other half is fixing it. Once you choose to act on a detected change, APISentry:
Clones the real linked GitHub repository at the branch you pick. Applies a fix, either through AI mode (Gemini reviews each affected file alongside the change description and only rewrites what actually needs to change — minimal, targeted diffs, not a wholesale rewrite) or manual mode (your own find/replace rules, plain string or regex, for full control). Commits with a real git commit, then either opens a real GitHub pull request on a new branch or commits directly to an existing one.
Nothing here is simulated. It shells out to the real git binary and calls the real GitHub REST API the same way a human contributor would.
Built and shipped on AWS
APISentry was built with standard open-source tooling Git, a headless browser for docs scanning, and the GitHub REST API and deployed on AWS. Amazon S3 stores documentation snapshots, diff history, and change records, giving the system memory across scans. AWS Secrets Manager securely holds API keys and credentials the Gemini key, GitHub tokens so nothing sensitive lives in the codebase.
Why this matters now
Agentic coding tools have already proven something important: teams are willing to grant an automated agent real access to a codebase, as long as it's genuinely useful and stays reviewable. APISentry takes that same trust model and flips it around. Instead of a vendor just announcing a change and hoping someone reads it, an agent scans for where that API is actually used in your code and proposes the fix — before it becomes an incident.
The gap between "a vendor silently changed something" and "your production traffic finds out the hard way" is where APISentry lives. Our goal is to make that gap a lot smaller.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article