A broken API is an application programming interface that fails to behave consistently, securely, or as documented. Practitioners use the term for endpoints with incorrect responses, weak authentication, missing authorisation checks, poor input validation, or unstable contracts that break client integrations and can expose data or actions to unintended callers.
What a broken API actually is
A broken API is not just an endpoint that returns an error. It is an interface whose behaviour is unreliable, insecure, or inconsistent with the contract clients depend on. That can include incorrect responses, broken authentication, missing authorization checks, weak validation, or unstable semantics that let callers do things the application owner never intended.
The key security point is that APIs are machine-to-machine control surfaces, so defects can affect automation at scale. When an API deviates from its documented behaviour, clients may retry, over-trust responses, or bypass logic in ways that create exposure far beyond a single failed request.
Why broken APIs are dangerous
Broken APIs are dangerous because they often fail in ways that are both quiet and repeatable. If authentication is weak, an attacker may impersonate a caller; if authorization is missing, they may read or modify objects they should never reach; if input validation is poor, malformed requests can trigger unexpected behaviour or data leakage.
This is why API issues are often more than availability problems. A broken contract can become a confidentiality, integrity, or abuse problem when clients and services assume the API is enforcing policy that is actually absent or incomplete.
For a broad reference point on common API failure modes, the OWASP API Security Top 10 is the most direct external guide to the class of weaknesses that commonly drive broken API conditions.
How broken APIs show up in practice
In practice, broken APIs usually surface as contract drift, inconsistent enforcement, or missing trust checks. One endpoint may validate a token while another accepts requests with weaker or no authentication. Another may return data for the wrong object because object-level authorization was never applied. Some APIs also fail when schemas, pagination, error handling, or rate limits are not enforced consistently across versions.
These flaws are especially damaging in distributed systems because different clients may observe different behaviour from the same API. That makes testing harder, creates brittle integrations, and increases the chance that a secure assumption in one part of the system is silently invalid elsewhere.
A useful way to think about the problem is that the API contract is part of the security boundary. If the contract is vague, inconsistently implemented, or not verified end to end, clients can accidentally depend on behaviour that was never safe to rely on.
Preventing and fixing broken API behaviour
Broken APIs are best prevented by treating authentication, authorization, validation, and contract consistency as first-class design requirements rather than optional implementation details. The goal is not only to make the endpoint work, but to make it behave predictably under normal use, abnormal input, and malicious traffic.
Practically, that means defining the contract clearly, enforcing it consistently across versions and routes, and verifying that every endpoint applies the same access rules and input constraints. Where APIs are exposed to untrusted callers or internal automation, security testing should confirm that the implementation matches the intended policy, not just the happy-path response shape.
The implementation guidance behind those checks is closely related to OWASP API Top 10 API2 Broken Authentication Guide, especially where the broken API condition comes from weak login, token handling, or service-to-service authentication.
Risk and Threat Considerations
Broken APIs create a direct abuse path because attackers do not need to defeat the whole application, only the weak endpoint or the inconsistent control point. The most common danger is not just downtime, but unauthorized access, object tampering, data exposure, and automation abuse at scale.
Failure mechanism: A caller exploits a missing or inconsistent control, such as weak authentication, absent authorization, unsafe object handling, or poor validation, and then uses the API exactly as implemented rather than as intended.
Impact: Sensitive records can be disclosed, business actions can be triggered without permission, and downstream systems may amplify the damage because they trust the API response or action result.
Standards & Framework Alignment
This section maps relevant standards and security frameworks to the operational risks and controls described in this guidance.
OWASP API Security Top 10 addresses the attack and risk surface, while NIST SP 800-53 Rev 5, OWASP ASVS and CIS Controls v8 set the governance and control requirements practitioners need to meet.
| Framework | Control / Reference | Relevance |
|---|---|---|
| OWASP API Security Top 10 | API2 — Broken Authentication | Broken API defects commonly include weak or inconsistent API authentication. |
| Recommendation — Enforce strong API authentication and validate tokens, sessions, and caller identity on every protected route. | ||
| NIST SP 800-53 Rev 5 | AC-3 — Access Enforcement | Broken APIs often fail by missing or inconsistently applying authorization checks. |
| Recommendation — Apply access enforcement checks to every API action and object access decision. | ||
| OWASP ASVS | V8 — Authorization | Broken APIs frequently expose object and function access control failures. |
| Recommendation — Verify authorization for every API object, action, and business function. | ||
| CIS Controls v8 | CIS-16 — Application Software Security | Broken APIs are application security defects requiring secure design, testing, and validation. |
| Recommendation — Build API security checks into development and testing to catch contract and control failures before release. | ||
Practitioner Guidance
Why practitioners should care: Broken API issues are often discovered only after clients, partners, or attackers have already relied on the flawed behaviour. For that reason, practitioners should treat contract consistency and access enforcement as part of release quality, not just security review.
What to watch for: Pay close attention to endpoints that behave differently across methods, versions, tenants, or object types, especially where a single missing check could expose a large data set or allow unintended state changes. Those are the places where broken APIs usually become security incidents.
Practitioner takeaway: A stable API is not merely one that responds, it is one that enforces the same security decision every time the same request is made.
Related resources from NHI Mgmt Group
Deepen Your Knowledge
Free weekly newsletter
Subscribe to the NHI & AI Identity Journal
The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.
Bonus 33% off our NHI Course when you subscribe.
Reviewed and updated by the NHIMG editorial team on November 16, 2026.
NHI Mgmt Group — the #1 independent authority on Non-Human Identity, IAM, and Agentic AI security. nhimg.org