Securing your APIs against the OWASP API Security Top 10
To secure your APIs against the OWASP API Security Top 10, drop the reflex of ticking off ten risks and build a control loop instead: design, testing, real-world exposure and remediation. That is the ground covered by continuous API security assessment, when you need to prove what is actually exposed, not just what appears in a schema.
Key takeaways
- The OWASP API Security Top 10 2023 puts authorization at the centre, not just authentication.
- API1, API2 and API3 are handled by testing objects, sessions and properties, not by adding a gateway.
- A WAF or gateway helps filter traffic, but it does not replace inventory, recurring tests or remediation.
- Serious coverage combines the contract, observation of production, negative testing and verification after the fix.
What to fix first
The starting point is not the list of ten risks. It is authorization. OWASP says it plainly in its 2023 release notes: "Authorization remains the biggest challenge in API Security. Three out of the top five items are related to authorization (access control)." That is where the most frequent access abuse happens, especially when object identifiers travel in parameters or request bodies.
If you do not fix object access, writable fields and sensitive functions, everything else stays fragile. A team can have solid SSO, clean JWTs and a well-tuned gateway, and still let one user read or modify another user's object. It is the most mundane case. It is also the most expensive one to miss.
Field data points the same way. According to Salt Labs, 95% of API attacks over the previous 12 months came from authenticated sources. In other words, authentication alone does not protect you from a logged-in user abusing their access.
- Inventory every exposed API, its versions, hosts and real usage.
- Lock down authorization at object, property and function level.
- Test abuse cases on concrete routes, with positive and negative cases.
- Watch production to spot forgotten endpoints, variants and abnormal usage.
In practice, most teams start in the wrong place. They harden the front door, then find out too late that a standard account can still make calls it should never see. In the OWASP ranking, API1, API2 and API3 come before any discussion of response format or log hygiene.
The ten OWASP risks translated into concrete controls
API1 to API5: access and resources
The first three items are the most sensitive for exposed APIs. API1:2023 covers object level authorization: an identifier must never be enough to read, modify or delete another user's object. API2:2023 covers broken authentication, when a token, a session or an authentication mechanism can be bypassed. API3:2023 covers authorization at property level: a sensitive field must not become writable just because it travels in the request body.
As the OWASP Top 10 itself puts it, "APIs tend to expose endpoints that handle object identifiers, creating a wide attack surface of Object Level Access Control issues."
API4:2023, unrestricted resource consumption, deserves early attention too. On a public API, that is often where denial of service, cost overruns and side effects on downstream systems hide. API5:2023, function level authorization, is the classic one teams forget: an admin action must not be reachable from a standard role through a direct call.
API6 to API10: flows, configuration and dependencies
API6:2023 targets sensitive business flows, such as changing an address, adding a payment method or approving a transfer. API7:2023 covers server-side request forgery, when an API can be pushed into calling an internal or unexpected resource. API8:2023 covers security misconfiguration. API9:2023 covers improper inventory management, and API10:2023 the unsafe consumption of third-party APIs.
That last one is often underestimated. An API that consumes other services inherits their risks on top of its own: response validation, URL filtering, forgotten dependencies, excessive trust in an internal service. In real incidents, these details are what turn a small weakness into a full compromise.
Cloudflare's 2024 API Security and Management Report found 30.7% more API endpoints through machine learning based discovery than organisations had declared themselves. That is the classic shadow API signal: what you think you expose is not always what you actually expose.
A security plan that holds over time
The baseline fits in a few building blocks: OAuth 2.0 or JWT for identity and scopes, TLS for transport, strict input validation, rate limiting, usable logging, and a central access policy where it makes sense. If your API gateway can only do coarse filtering, it reduces noise but does not close the problem.
A good test starts on real endpoints, not demo examples. Take GET /accounts/{id}, PATCH /users/{id} or POST /payments. Check an allowed case, a forbidden case, then an awkward one: missing identifier, insufficient role, unexpected field, invalid format. A useful access control has to resist those variants, not just the happy path.
On fast-moving teams, the real difference comes from repetition. A test run once in staging proves nothing if your OpenAPI schema changed the following week or a new role was added to the back office. That is where a recurring cycle beats a one-off audit.
What teams should automate first
- BOLA: check whether a user can reach another user's object by changing only the identifier.
- BFLA: check that a sensitive function cannot be reached from a standard role.
- OpenAPI contract: compare what is published with what is actually served.
- Resource limits: push pagination, search and volume cases to see where things break.
Teams that expose many APIs quickly hit the question of time to fix. A critical finding that stays open for weeks while the API stays online is the gap attackers use. Tracking each finding through ticket, fix and retest is what closes it.
Why inventory matters as much as testing
You cannot secure an API you cannot see. Shadow and zombie APIs are often the most exposed, because they sit outside the contract, escape reviews and survive partial rewrites. That is why OWASP API9 exists: poor inventory management is not an organisational detail, it is a security flaw.
The same blind spots come up again and again: an old host kept for compatibility, a v1 still live, a test route left in production, a webhook documented in a ticket but not in the API gateway. Without a continuous view, you are relying on luck.
In regulated sectors the pressure is higher. The more central APIs become to payments and critical business flows, the wider their attack surface gets.
Choosing tools without picking the wrong layer
If your main need is to filter traffic at the edge, an API gateway or a WAF can be enough. If you need to detect and prove application-level abuse, you need more than a border guard. That is where testing tools fit better than purely perimeter controls.
- Pentest of the API: exploits real abuse cases (BOLA, BFLA, property tampering, business flows) and proves them. It does not filter live traffic.
- Gateway, WAF or API management: applies entry policies, controls traffic, centralises some access. It does not always see business logic errors or object level authorization abuse.
- One-off manual tests: explore a route, a scenario or a regression quickly. They give no lasting coverage and little evidence over time.
- Spreadsheet tracking: simple for a small scope, but fragile, manual and quickly out of date.
For a platform or AppSec team, the right choice depends on the deliverable. A WAF protects a surface, but it will not tell you whether one user can read another user's object. A passive discovery tool sees endpoints, but it does not demonstrate their abuse. If your constraint is lasting API coverage and proof of remediation, look at the ability to replay tests, follow changes and keep auditable traces. Our API pentesting tools selection guide goes deeper on that choice.
What Fleuret does on APIs
Fleuret runs agentic pentests on REST and GraphQL APIs, web apps and external infrastructure, with results in hours. Each finding comes with a replayable proof of concept, is pushed to Jira, Linear or Slack, and can be retested once the fix ships. For teams answering to DORA or NIS2, findings are mapped to both texts and a signed report is available on demand.
On environments where APIs change often, that avoids the classic pattern: a reassuring annual audit followed by six months of drift. The starting point stays the same: what you actually expose.
The mistakes that leave APIs vulnerable
- Believing authentication is enough: a logged-in user can still abuse rights granted too broadly.
- Forgetting writable properties: a sensitive field can be altered without breaking the route or the token.
- Leaving resources unbounded: one expensive request can saturate the API or downstream services.
- Keeping dead versions alive: a forgotten old route attracts abuse because it is watched less.
- Ignoring outbound calls: API10 is a reminder that a consuming API can become an attack's entry point.
Sensitive flows deserve special attention. Password changes, address changes, new beneficiaries, data exports and webhooks are natural targets. On those scenarios, security is not limited to the technical perimeter, it reaches into the business logic itself.
The right reflex is simple: if an action can have a meaningful effect on an account, a payment or an access right, test it off the nominal path. Not once. At every significant change.
The right call for your need
If your only goal is to filter traffic at the network edge, pick a gateway or a WAF. If you want to secure your APIs against the OWASP API Security Top 10 with evidence, recurring tests and a defensible remediation loop, test the API itself, prove each abuse case and retest after the fix.
Fleuret runs agentic pentests on REST and GraphQL APIs with replayable PoCs, tickets in your tracker and a retest after the fix. See Fleuret in action.
Sources
- OWASP API Security Top 10 2023, OWASP, 2023
- OWASP API Security Top 10 2023 release announcement, OWASP API Security Project, 2023-07-03
- State of API Security Report, Salt Labs, 2025
- 2024 API Security and Management Report, Cloudflare, 2024
Your turn.
En garde.
The Free plan runs SAST, DAST, SCA and secret scanning for 2 users and 10 repos, no call needed. Several apps or an audit deadline? Book a demo instead.
