Most of what a modern application does happens through its API. The web front end, the mobile app, partners' integrations and your own background jobs all call the same endpoints, and attackers call them too, usually with a script rather than a browser. So when a security review, a pentest report or a customer questionnaire asks about API risk, it almost always does it in the words of the OWASP API Security Top 10.
This post explains the list as it stands today, the 2023 edition, item by item. Each item gets one concrete threat on the same system: Invoicely, a fictional SaaS invoicing app whose API lets businesses create invoices, email them as PDFs and get paid through Stripe. It's the system from our threat model example, and one of the free example models in ThreatTree, so you can open it and follow along. Four of the ten items are already threats in it, with scores. The other six are threats you'd add.
The short version: the OWASP API Security Top 10 is a ranked list of the ten most critical security risks in APIs, published by the OWASP API Security Project. The current edition is the 2023 list: API1 Broken Object Level Authorization, API2 Broken Authentication, API3 Broken Object Property Level Authorization, API4 Unrestricted Resource Consumption, API5 Broken Function Level Authorization, API6 Unrestricted Access to Sensitive Business Flows, API7 Server Side Request Forgery, API8 Security Misconfiguration, API9 Improper Inventory Management and API10 Unsafe Consumption of APIs. Three of the ten are authorization failures. It's an awareness list, not a standard: use it in a threat model as a checklist for each part of your API and as a label on the threats you find, not as the threat model itself.
What the list is, and why APIs got their own
The OWASP Top 10 covers web applications in general. APIs fail in ways that list describes only loosely. An API hands out objects by ID, so authorization has to be checked per object, per field and per function, and one missing check is a data breach. Clients are scripts, so anything that can be called can be called a million times. And APIs multiply: versions, internal endpoints and partner integrations pile up faster than anyone keeps track of them.
OWASP published the first API Security Top 10 in 2019 and the current edition in June 2023. The 2023 update added three items: abuse of sensitive business flows (API6), server side request forgery (API7) and unsafe consumption of third-party APIs (API10). It merged excessive data exposure and mass assignment into one property-level authorization item (API3), and dropped injection and insufficient logging, which are still risks but are better covered elsewhere. As of 18 November 2026, the 2023 list is still the current edition, and the project's site has moved to api-security.owasp.org.
The ten at a glance
| ID | Risk | In one line | Invoicely example |
|---|---|---|---|
| API1 | Broken Object Level Authorization | The API doesn't check you may use this object | Change the invoice ID, read another customer's invoice |
| API2 | Broken Authentication | Logins, tokens or resets can be guessed, stolen or skipped | Credential stuffing with leaked passwords |
| API3 | Broken Object Property Level Authorization | You may use the object, but not every field of it | Setting your own plan to "pro" in a profile update |
| API4 | Unrestricted Resource Consumption | Nothing limits how much one caller can use | Thousands of PDF renders queued by one account |
| API5 | Broken Function Level Authorization | Admin functions callable by ordinary users | A customer calls the support team's endpoints |
| API6 | Unrestricted Access to Sensitive Business Flows | A legitimate feature, abused at scale | Phishing "invoices" sent from Invoicely's domain |
| API7 | Server Side Request Forgery | The API fetches a URL the caller chose | A logo URL that points at the cloud metadata service |
| API8 | Security Misconfiguration | Unsafe defaults, headers, errors or CORS | Stack traces with internal hostnames in error responses |
| API9 | Improper Inventory Management | Forgotten versions and hosts still answer | The old v1 invoice endpoint, without the new checks |
| API10 | Unsafe Consumption of APIs | Data from third-party APIs trusted blindly | A forged "payment succeeded" webhook |
The ten risks, one by one
API1: Broken Object Level Authorization
Broken object level authorization (BOLA) is an API returning or changing an object, an invoice, an account or a file, without checking that the caller may use that particular object. Checking that the caller is logged in isn't enough. It has been first since the list began, because almost every endpoint takes an object ID and one missing check is enough. It's the API form of what's usually called IDOR, which our knowledge base entry on insecure direct object references covers in detail.
In Invoicely: ownership is checked in the web app's screens but not on every API endpoint, so a customer who changes the invoice ID in a request can read another business's invoices. It's T2 in the example model and its highest-scoring threat: likelihood 4 × impact 5 = 20, Critical. First controls: one shared authorization check that every invoice and PDF endpoint goes through, and tests that call each endpoint as a second customer.
API2: Broken Authentication
This covers everything that proves who the caller is: login, password reset, tokens and API keys. Typical failures are no protection against password guessing, tokens that never expire or aren't validated properly, and reset flows that can be abused. APIs make it worse because login endpoints are easy to script against.
In Invoicely: the login endpoint has no rate limit and no check for breached passwords, so attackers replay leaked email and password pairs until some work. It's T1 in the example model, scored 4 × 4 = 16, Critical. First controls: rate limiting per account and per IP address, a breached-password check, and two-factor authentication offered to every customer.
API3: Broken Object Property Level Authorization
The caller may use the object, but not every field of it. The item merges two 2019 items: excessive data exposure, where a response includes fields the caller shouldn't see, and mass assignment, where an update accepts fields the caller shouldn't be able to set. Both come from binding requests and responses straight to database models.
In Invoicely: a PATCH /users/me request accepts any field of the user record, so adding "plan": "pro" upgrades a free account, and the same response returns the internal Stripe customer ID. It isn't in the example model yet. First controls: an explicit list of the fields each endpoint may read and write, separate from the database model, and response schemas checked in tests.
API4: Unrestricted Resource Consumption
Every request costs something: CPU, memory, storage, emails, text messages, or calls to a paid third-party API. Without limits on how much one caller can use, an attacker or a buggy client can exhaust capacity for everyone, or run up a bill. The 2023 name replaced "lack of resources and rate limiting" because the cost is often money rather than downtime.
In Invoicely: any account can queue thousands of PDF renders, and there's no per-account limit, so invoice sending stalls for every customer at month end. It's T9 in the example model, scored 3 × 3 = 9, Medium. First controls: per-account quotas on renders and emails, maximum page sizes and file sizes, and a queue that serves accounts fairly.
API5: Broken Function Level Authorization
API1 is about which objects a caller may use; API5 is about which functions. Administrative or internal operations sit in the same API as everything else, and are protected only by not being linked from the user interface. Endpoints that differ only by HTTP method, such as a DELETE next to a harmless GET, are a common gap.
In Invoicely: the support team's endpoints under /admin check that the caller is logged in, not that they're on the support team, so any customer who finds them can look up other customers. It's not in the example model, but it sits next to T5, the admin console sharing the API's database role. First controls: deny by default, a role check on every administrative route, and a test that calls each one as an ordinary customer.
API6: Unrestricted Access to Sensitive Business Flows
Here nothing is broken. A legitimate feature, buying, booking, signing up, sending, works exactly as designed, but used automatically and at scale it harms the business. Ticket scalping, mass account creation and referral abuse are the classic cases. A threat model finds these by asking, for each flow, what happens if a script does it ten thousand times.
In Invoicely: free trial accounts can email an invoice to any address, from Invoicely's own trusted domain, with a payment link in it. Fraudsters sign up in bulk and use it to send phishing "invoices". Invoicely's email reputation and its customers' trust suffer, even though no endpoint is vulnerable. First controls: limits on sending for new and unverified accounts, verification of the sender's business, and monitoring of invoice volume and bounce rates per account.
API7: Server Side Request Forgery
Server side request forgery (SSRF) is the API fetching a URL that the caller supplies, for an import, a webhook, a preview or an image, so the request comes from inside your network. Attackers point it at internal services or at the cloud provider's metadata endpoint to steal credentials. Our knowledge base entry on SSRF covers how it works and what stops it.
In Invoicely: customers can set their company logo by URL, and the PDF worker downloads it when it renders each invoice. A logo URL pointing at 169.254.169.254 returns the worker's cloud credentials into the PDF. It isn't in the example model yet. First controls: upload logos instead of fetching them; if URLs stay, fetch through an egress proxy that blocks private and metadata addresses, and require IMDSv2 on AWS.
API8: Security Misconfiguration
Misconfiguration covers everything around the code: missing TLS or security headers, permissive CORS, verbose errors, unnecessary HTTP methods, default credentials and unpatched components. It's rarely one big mistake. It's the gap between how each environment should be set up and how it actually is.
In Invoicely: the production API runs with the framework's debug mode on after an incident, so error responses include stack traces, internal hostnames and database names. It isn't in the example model yet. First controls: configuration kept in code and reviewed, generic error responses in production, and an automated check of headers, CORS and debug settings on every deployment.
API9: Improper Inventory Management
You can't protect endpoints you've forgotten. Old API versions, staging and test hosts, internal endpoints exposed by accident and undocumented partner APIs keep running long after anyone looks at them, often without the fixes the current version received. Inventory also means knowing which data flows to which third parties.
In Invoicely: the fix for API1 went into the v2 API. The old /v1/invoices endpoint is still deployed for one large customer's integration, and it doesn't use the new ownership check, so the critical threat from API1 is still open through v1. First controls: an inventory of every API version, host and consumer, kept up to date by the deployment pipeline, and a date to retire each old version. The REST API threat modeling guide starts with exactly this inventory.
API10: Unsafe Consumption of APIs
APIs also consume other APIs: payment providers, identity providers, address lookups, AI models. Developers tend to trust what comes back from a well-known provider more than user input, so data from third parties is used without validation, and their callbacks are accepted without checking where they came from.
In Invoicely: if the signature on Stripe's webhook isn't verified, anyone can send a "payment succeeded" event and mark an invoice as paid. It's T4 in the example model, scored 2 × 5 = 10, High. First controls: verify every webhook's signature, treat third-party data as untrusted input, and confirm important events with a call back to the provider's API.
How to use the list in a threat model
The Top 10 tells you what to look for. It doesn't tell you where those problems are in your API, how likely they are or what to fix first. That's the threat model's job:
- Draw the API as it really is. A data flow diagram with the gateway, each API version, the admin endpoints, workers and every third-party API as separate elements, and a trust boundary wherever callers or data cross from outside. Old versions and webhooks belong on it; they're where API9 and API10 live.
- Walk the list per element. Use the diagram above as a guide to which items apply where, and STRIDE for everything else. The REST and GraphQL guides show the questions to ask per endpoint.
- Build attack trees for outcomes. "Read another customer's invoices" can happen through API1 on v2, API1 again on v1 (API9) or stolen sessions (API2). An attack tree with that goal shows that fixing v2 alone doesn't close it.
- Label each threat with its item. Labels let you answer "what have we done about API3?" quickly, and show a reviewer which items have threats against them and which don't.
- Write down the gaps on purpose. For every item with no threat, say why: "API7: the API never fetches a URL a customer supplies" is an answer a reviewer can check. A blank isn't.
API Top 10 vs. the OWASP Top 10
The two lists overlap, and an API needs both. The table shows the closest OWASP Top 10 (2025) category for each API item. It's our mapping, not an official one, and two items have no real equivalent.
| API Security Top 10 (2023) | Closest OWASP Top 10 (2025) |
|---|---|
| API1 Broken Object Level Authorization | A01 Broken Access Control |
| API2 Broken Authentication | A07 Authentication Failures |
| API3 Broken Object Property Level Authorization | A01 Broken Access Control |
| API4 Unrestricted Resource Consumption | None (a denial-of-service and cost risk) |
| API5 Broken Function Level Authorization | A01 Broken Access Control |
| API6 Unrestricted Access to Sensitive Business Flows | A06 Insecure Design |
| API7 Server Side Request Forgery | A01 Broken Access Control (SSRF was folded into it in 2025) |
| API8 Security Misconfiguration | A02 Security Misconfiguration |
| API9 Improper Inventory Management | None (an asset inventory problem) |
| API10 Unsafe Consumption of APIs | A08 Software or Data Integrity Failures |
The pattern is clear: three API items collapse into one web category, A01. That's the point of the API list. Telling a team they have "broken access control" doesn't say where to look; telling them it's per object, per field or per function does.
What the list can't do
- It isn't a standard you comply with. There are no requirements, no levels and no certification, so "OWASP API Top 10 compliant" doesn't mean anything specific. For verifiable requirements, OWASP points to its Application Security Verification Standard (ASVS).
- It doesn't rank your risks. The order reflects how common and damaging each item is across many APIs. In Invoicely, API1 scores 20 and API4 scores 9; in an API that sends text messages at your expense, API4 could be first.
- Scanners find only some of it. Misconfiguration and some authentication flaws show up in automated tests. The authorization items and business-flow abuse mostly don't, because the requests look valid. Those come from understanding who should be allowed to do what, which is what a threat model records.
- It doesn't cover the rest of the system. Injection, logging and the cloud account behind the API are outside it, and still need their own threats.
Frequently asked questions
What is the OWASP API Security Top 10?
It's a list of the ten most critical security risks in APIs, published by the OWASP API Security Project. The current edition is the 2023 list: broken object level authorization, broken authentication, broken object property level authorization, unrestricted resource consumption, broken function level authorization, unrestricted access to sensitive business flows, server side request forgery, security misconfiguration, improper inventory management and unsafe consumption of APIs.
What is the number one API security risk?
Broken object level authorization (BOLA), API1, in both the 2019 and 2023 editions. It means an API returns or changes an object, such as an invoice or an account, without checking that the caller is allowed to use that particular object. Changing an ID in a request is often all it takes, and automated scanners rarely find it because the request looks valid.
What changed in the 2023 OWASP API Security Top 10?
Three items are new: unrestricted access to sensitive business flows (API6), server side request forgery (API7) and unsafe consumption of APIs (API10). Excessive data exposure and mass assignment were merged into broken object property level authorization (API3). Lack of resources and rate limiting became unrestricted resource consumption. Injection and insufficient logging and monitoring were dropped from the list, though both still matter.
How is the API Security Top 10 different from the OWASP Top 10?
The OWASP Top 10 covers web application risks in general, such as broken access control and injection. The API Security Top 10 breaks the authorization problem into the forms it takes in APIs, per object, per property and per function, and adds API-specific risks such as business-flow abuse, unsafe use of third-party APIs and forgotten API versions. An application with an API should be checked against both.
Is there a newer version than the 2023 OWASP API Security Top 10?
As of 18 November 2026, the 2023 list is still the most recent edition; the only earlier one is from 2019. The project's site has moved to api-security.owasp.org, which is where a new edition would appear.