What Is the OWASP API Security Top 10? The 2023 List Explained

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

IDRiskIn one lineInvoicely example
API1Broken Object Level AuthorizationThe API doesn't check you may use this objectChange the invoice ID, read another customer's invoice
API2Broken AuthenticationLogins, tokens or resets can be guessed, stolen or skippedCredential stuffing with leaked passwords
API3Broken Object Property Level AuthorizationYou may use the object, but not every field of itSetting your own plan to "pro" in a profile update
API4Unrestricted Resource ConsumptionNothing limits how much one caller can useThousands of PDF renders queued by one account
API5Broken Function Level AuthorizationAdmin functions callable by ordinary usersA customer calls the support team's endpoints
API6Unrestricted Access to Sensitive Business FlowsA legitimate feature, abused at scalePhishing "invoices" sent from Invoicely's domain
API7Server Side Request ForgeryThe API fetches a URL the caller choseA logo URL that points at the cloud metadata service
API8Security MisconfigurationUnsafe defaults, headers, errors or CORSStack traces with internal hostnames in error responses
API9Improper Inventory ManagementForgotten versions and hosts still answerThe old v1 invoice endpoint, without the new checks
API10Unsafe Consumption of APIsData from third-party APIs trusted blindlyA forged "payment succeeded" webhook
A diagram of the Invoicely invoicing API with each OWASP API Security Top 10 2023 item placed where it occurs. Top row: Customer (browser app or a script) calls the API gateway (login, tokens, rate limits; API2, API4, API8), which calls the Invoicely API v2 (invoices, customers, send invoice by email; API1, API3, API6), which reads the Database of all customers' invoices. The customer can also call the Old v1 API directly, with no gateway (API9). The gateway also routes to Admin endpoints for support (API5). Stripe sends payment events to the API by webhook (API10). The API sends render jobs to the PDF worker (API4, API7), which fetches a logo URL from a logo host that can be any URL, including cloud metadata.
Where each item sits in Invoicely's API. The three authorization items, API1, API3 and API5, are about the same question asked at three levels: this object, this field, this function.

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:

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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 AuthorizationA01 Broken Access Control
API2 Broken AuthenticationA07 Authentication Failures
API3 Broken Object Property Level AuthorizationA01 Broken Access Control
API4 Unrestricted Resource ConsumptionNone (a denial-of-service and cost risk)
API5 Broken Function Level AuthorizationA01 Broken Access Control
API6 Unrestricted Access to Sensitive Business FlowsA06 Insecure Design
API7 Server Side Request ForgeryA01 Broken Access Control (SSRF was folded into it in 2025)
API8 Security MisconfigurationA02 Security Misconfiguration
API9 Improper Inventory ManagementNone (an asset inventory problem)
API10 Unsafe Consumption of APIsA08 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.

Threat model your API in ThreatTree

Draw your API as a data flow diagram, with every version, worker and third-party API on it. Build an attack tree for each outcome that matters, tag each threat with its OWASP Top 10 category and CAPEC pattern, score it, and track the fixes in a risk register with owners, free on every plan. Start from Invoicely, the example in this post: it already has scored threats for four of the ten items.

Or start a blank model →

Not ready to sign up? Get new threat-modeling guides by email instead.