Most API misconfigurations are not bugs in code. They are settings that were wrong from the start, or right until a release changed them. Here is how Data Theorem finds both.
An API misconfiguration rarely looks like a vulnerability. There is no bad function to point at and often no CVE to track. An endpoint is reachable when it should not be. A credential is weaker than it should be. An access check passes when it should fail.
That makes misconfigurations easy to miss in code review and easy to reintroduce. An API that passed review in March can be a different API in June. A release changes a route, a migration moves a service, a new flow skips a control that used to be there.
Data Theorem’s approach to API misconfigurations rests on three ideas. Test every operation, not just every API. Watch posture with every release, not once a year. And test the way real users and real attackers interact with your APIs, signed in and signed out.
WorkOS: An Exposed Internal API and an AI Agent
In October 2026, an AI agent found an internal tool’s API endpoints exposed to the internet, signed in with weak credentials and pulled records in bulk because nothing limited its rate. WorkOS said the right controls would have mitigated or prevented the incident.
Sources: WorkOS security bulletin; The Hacker News.
Every Operation Gets Its Own Grade
Authentication, authorization and encryption are not set once per API. They are set per operation. A well-protected POST can sit next to a GET that anyone can call. A versioned endpoint can keep an old, weaker authentication method long after the new one ships.
That is why API Secure scores every operation on its own across four areas: authentication, authorization, encryption and open security issues. It then rolls those scores into one grade for your whole API landscape. Security teams get a single number to track. Developers get the exact operation that pulled the grade down.
API Secure probes your APIs from the outside, the way an attacker first sees them. It tests each operation unauthenticated and authenticated, so an operation that answers without credentials stands out immediately.
Two Automakers: A Default Password Behind an Edge Rule
Researchers found the identity servers behind two car brands’ apps still exposed an admin console with its documented default password. An edge rule hid it, but the edge and the server read the same address differently. The result was takeover of any customer account. A separate chain used admin credentials left in the app’s code.
Sources: Sam Curry: ForgeRock research; The Hacker News. Related: Hardcoded Credentials in Mobile Apps.
The API You Reviewed Is Not the API You Run
Most teams review an API once, at design or before launch. The API keeps changing after that. New releases, framework upgrades, gateway changes and infrastructure moves all touch security settings, and few of those changes get a second review.
We call this API drift: the deployed API no longer matches what was reviewed or documented. Drift is not only new endpoints. It is security posture that quietly gets weaker. The patterns we see most often:
Authentication disabled or broken. An operation that required credentials now answers without them, or accepts credentials it should reject.
TLS downgraded. An API that enforced a modern Transport Layer Security (TLS) version now accepts an older, weaker one.
Authentication scheme downgraded. An operation moves from a strong scheme to a weaker one, often during a migration or a quick fix.
Security headers lost. Headers that told browsers and clients how to handle responses disappear after a release.
The sharpest form of drift is the Leaky API: an API that was protected becomes unprotected after a new release. API Secure watches how posture changes with every release and flags each of these drift patterns when it appears. When a release leaves a protected API unprotected, API Secure flags it as a Leaky API and alerts your team right away, not at the next annual test.
DigiCert: A Migration That Left a System Open
A server migration made an internal DigiCert business system reachable from the internet in February 2025. Accounts created through an exposed registration flow skipped multifactor authentication and still got read-only access to archived customer records. An unauthorized account used that access in mid-2026.
Sources: BleepingComputer; DigiCert’s full incident report (Mozilla Bugzilla 2084460).
Signing In Is Not the Same as Being Allowed In
Some of the most damaging API misconfigurations only appear after login. Authentication works. Authorization does not. Two flaws lead the list:
Broken object level authorization (BOLA). A signed-in user changes an ID in a request and reads or edits another user’s data.
Privilege escalation. A regular user reaches operations meant only for administrators.
Neither shows up in a scan that never signs in. API Secure runs fully authenticated testing and uses your identity provider to stay logged in through the whole test. It then signs in as two different users and proves when one can reach the other’s data. That turns a theoretical authorization concern into a finding with evidence.
Authorization rules are specific to each business, so API Secure also runs custom authenticated checks. You pick the API and the signed-in user, then state what should happen, such as “User A must not read User B’s account.” The check runs with every scan, and API Secure flags any check that fails. Teams use custom checks to catch BOLA, privilege escalation and the backend misconfigurations behind them. For more on how this testing works, see API Security Testing.
AI-Built Apps: A Sign-In Check That Always Passed
Researchers testing an app built by an AI app builder found the generated code added each person who signed in to the team before checking whether they belonged. An uninvited account viewed every customer record, edited one and deleted another.
Sources: The Hacker News.
Fix the Configuration, Cover the Gap
Finding a misconfiguration is the start. Fixing it can take a release cycle, and attackers do not wait for one.
API Secure’s runtime protection works through the web application firewall (WAF) you already run. It spots attacks against your APIs and has that WAF block them, with no new appliance in the path. See API Runtime Protection for how it works.
Runtime protection is cover while the fix ships, not a replacement for the fix. Edge rules can be bypassed, as the automaker research showed. The durable answer is the corrected configuration, verified by the next test.
API misconfigurations are not one-time mistakes. They come back with every release. Your testing has to come back just as often.
Schedule a demo to see how API Secure grades every operation, catches drift and Leaky APIs, and proves authorization flaws before attackers find them.
Schedule a demo


