APIs now carry most of the traffic between apps, partners and back-end services, and attackers have followed. The OWASP API Security Project maintains a Top 10 list of the most important API security risks. Its project page lists 2023 as the latest version, and that edition is the one this guide covers.
The list is not a compliance checklist, and it does not cover every possible weakness. It is a shared vocabulary for the problems that show up most in real APIs. Below, each risk is explained in plain terms, with what it tends to look like in code and the controls that address it.
The 2023 list at a glance
| ID | Risk |
|---|---|
| API1:2023 | Broken Object Level Authorization |
| API2:2023 | Broken Authentication |
| API3:2023 | Broken Object Property Level Authorization |
| API4:2023 | Unrestricted Resource Consumption |
| API5:2023 | Broken Function Level Authorization |
| API6:2023 | Unrestricted Access to Sensitive Business Flows |
| API7:2023 | Server Side Request Forgery |
| API8:2023 | Security Misconfiguration |
| API9:2023 | Improper Inventory Management |
| API10:2023 | Unsafe Consumption of APIs |
Three of the ten are about authorization. That is the clearest message of the list: most API breaches are not about breaking encryption, but about the API doing what it was asked by someone who should not have been allowed to ask.
The risks, one by one
API1: Broken Object Level Authorization
OWASP notes that APIs tend to expose endpoints that handle object identifiers. The classic bug: GET /invoices/1043 returns the invoice to any signed-in user, not only its owner. Changing the number in the URL reveals someone else’s data.
Controls: check, in every function that loads data by an ID from the request, that the caller may access that specific object. Centralize the check so it cannot be forgotten, and write tests that request another user’s or tenant’s records.
API2: Broken Authentication
Authentication mechanisms implemented incorrectly let attackers compromise tokens or assume other users’ identities.
Controls: use proven libraries and identity providers rather than custom token schemes; validate token signature, issuer, audience and expiry; rate-limit login and password reset; and protect credential recovery flows as carefully as login itself.
API3: Broken Object Property Level Authorization
This category combines two risks from the 2019 edition, Excessive Data Exposure and Mass Assignment. The root cause is missing authorization at the level of individual properties. An API might return a user object including an internal isAdmin flag, or accept a role field in an update request that the user should never be able to set.
Controls: define explicit response schemas that list allowed fields; never bind request bodies straight onto database models; and keep an allow-list of fields each role may write.
API4: Unrestricted Resource Consumption
Every request costs bandwidth, CPU, memory and storage. Some cost money directly, such as sending an SMS or email through a paid provider. OWASP notes that successful attacks can cause denial of service or higher operating costs.
Controls: rate limits per user and per client, maximum page sizes, upload size limits, timeouts, and spending caps on paid third-party services triggered by the API.
API5: Broken Function Level Authorization
Complex role structures and an unclear line between administrative and regular functions lead to flaws where ordinary users can call admin operations.
Controls: deny by default, group administrative functions behind a separate authorization layer, and test every privileged endpoint with an unprivileged account.
API6: Unrestricted Access to Sensitive Business Flows
Some flows are harmful when automated at scale even if no single request is invalid: buying up limited stock, creating fake accounts, posting spam. OWASP points out that this risk does not necessarily come from implementation bugs.
Controls: identify the flows that would hurt the business if abused, then add friction proportionate to the risk, such as per-account limits, device or behavior signals, and human verification where appropriate.
API7: Server Side Request Forgery
When an API fetches a remote resource from a user-supplied URL without validation, an attacker can make the server send requests to unexpected destinations, including internal systems behind a firewall.
Controls: avoid fetching arbitrary URLs where possible; otherwise allow-list destinations, block internal address ranges, disable redirects, and run fetchers in isolated network segments.
API8: Security Misconfiguration
APIs and their supporting systems have many settings, and missing one opens the door: verbose error messages, permissive cross-origin rules, unpatched components, default credentials.
Controls: hardened configuration as code, automated checks in the deployment pipeline, consistent error handling that hides internals, and regular patching.
API9: Improper Inventory Management
APIs tend to expose more endpoints than traditional web applications. OWASP stresses that up-to-date documentation and an inventory of hosts and deployed versions help prevent problems such as forgotten old versions and exposed debug endpoints.
Controls: maintain an API inventory generated from code or gateways, retire old versions on a schedule, and keep non-production environments away from production data.
API10: Unsafe Consumption of APIs
OWASP observes that developers tend to trust data from third-party APIs more than user input. Attackers exploit this by targeting the integrated services instead of your API directly.
Controls: validate and sanitize data from partners and providers just as you would user input, enforce TLS, limit redirects, and set timeouts and size limits on third-party responses.
Turning the list into practice
A Top 10 list helps most when it becomes part of how work gets done, not a one-off review. A practical approach:
- Design. For each new endpoint, write down who may call it, which objects it touches and which fields they may read or change.
- Build. Use shared middleware for authentication, object-level checks, rate limits and response schemas, so every endpoint gets them by default.
- Test. Add automated tests for authorization failures, not just successes: another tenant’s ID, an unprivileged user on an admin route, an extra property in an update.
- Review. Include the ten risks as prompts in code review for API changes.
- Operate. Keep an inventory, monitor for unusual usage patterns, and alert on spikes in authorization failures.
A quick self-assessment
- Does every endpoint that takes an object ID check access to that specific object?
- Do responses use explicit schemas rather than serializing whole database records?
- Are there rate and size limits on every public endpoint?
- Can you list every API host and version currently running?
- Is data from third-party APIs validated before use?
If any answer is “not sure”, that is where to start.
How Devacon can help
We design and build APIs with authorization, input validation, rate limiting and inventory built in, and we review existing APIs against the OWASP API Security Top 10. A typical engagement includes a prioritized list of findings and the fixes and tests to close them. Learn more about our API development and integration services.
Sources
Facts in this article were checked against the sources above on November 17, 2026. Standards and products change, so check the source before relying on a detail. Related service: API Development & Integration.