On this page
An API security checklist is a list of yes-or-no checks that shows whether an API handles authorization, authentication, limits, configuration and outbound calls safely. This one has 30 checks in five areas, each mapped to the OWASP API Security Top 10, with a test for every area that a small team can run.
The checklist is written for teams that are about to face a customer security review or a first penetration test, and for founders whose backend was partly written by an AI tool. If you would like a second pair of eyes on the result, our code audit services cover security alongside architecture, tests and delivery risk.
The top 10 API security risks, in plain words
The top 10 API security risks are the ten failure types in the OWASP API Security Top 10. The 2023 edition is the second one, after 2019, and as of November 2026 it is the latest that OWASP lists. Three of the ten are authorization failures, more than any other kind.
OWASP calls the API Security Top 10 an awareness document. It ranks what goes wrong; it is not a standard to certify against. The table restates each risk in a sentence.
| Risk | What goes wrong | Checklist area |
|---|---|---|
| API1 Broken Object Level Authorization | A user changes an ID in a request and reads or edits someone else's record. | Authorization |
| API2 Broken Authentication | Logins, tokens or password resets can be guessed, forged or replayed. | Authentication |
| API3 Broken Object Property Level Authorization | A response exposes fields the user should not see, or an update sets fields the user should not control. | Authorization |
| API4 Unrestricted Resource Consumption | Requests have no limit on rate, size or cost. | Limits and abuse |
| API5 Broken Function Level Authorization | A regular user can call an administrative function. | Authorization |
| API6 Unrestricted Access to Sensitive Business Flows | A flow such as buying or booking can be automated in a way that harms the business. | Limits and abuse |
| API7 Server Side Request Forgery | The API fetches a URL that a user supplied and reaches somewhere it should not. | Outbound calls |
| API8 Security Misconfiguration | Defaults, missing encryption, loose cross-origin rules or verbose errors open a door. | Configuration and inventory |
| API9 Improper Inventory Management | Old versions, test hosts or undocumented endpoints stay reachable. | Configuration and inventory |
| API10 Unsafe Consumption of APIs | Data from a third-party API is trusted more than user input. | Outbound calls |
API security checklist: 30 checks in five areas
The checklist has 30 checks: three for each of the ten risks, grouped into five areas so that one person can own each area. Answer every check with yes, no or not applicable, and treat "not sure" as a no.
Authorization (9 checks: API1, API3 and API5)
- Every endpoint that takes an object ID checks, on the server, that the caller may act on that object.
- The owner or tenant is read from the stored record, never from a field the client sent.
- Automated tests call each endpoint as a second user and expect a refusal.
- Responses return named fields only, not a whole database object.
- Updates accept a fixed list of writable fields, so a client cannot set a role, a plan or an owner.
- Response shapes are defined in a schema and checked against it.
- Access is denied by default, and each function is granted to named roles.
- Administrative functions check the caller's role on the server, whatever path they sit under.
- Changing the HTTP method on a request, for example from GET to DELETE, does not get past the role check.
OWASP also suggests random, unpredictable record IDs. They make guessing harder, and they do not replace the check.
Authentication (3 checks: API2)
- Login, password reset and one-time code endpoints have stricter rate limits than the rest of the API, with lockout or a challenge after repeated failures.
- Every request validates the token's signature, expiry, issuer and audience, with the signing algorithm fixed by the server.
- Changing an email address, a password or a second factor asks the user to authenticate again, and no credential or token travels in a URL.
Two details come straight from the source documents. OWASP states that API keys should not be used for user authentication, only to identify client applications. The IETF's RFC 8725 on JSON Web Tokens (JWTs) requires that libraries let the caller specify which algorithms are accepted, which is how a token with the algorithm set to "none" gets rejected.
If you use OAuth 2.0, check your flows against RFC 9700, the IETF's best current practice from January 2025. Public clients must use Proof Key for Code Exchange (PKCE), and the resource owner password credentials grant must not be used. Redirect URIs are compared by exact string matching, with one narrow exception for native apps on localhost.
Limits and abuse (6 checks: API4 and API6)
- Every endpoint has a rate limit per client, and a client over the limit gets a 429 response.
- The server caps request body size, upload size, array length and page size.
- Requests have execution timeouts, and paid services called per request, such as SMS or email, have a spending limit or a billing alert.
- The team has listed the flows that would hurt if automated: sign-up, purchase, booking, posting.
- Each of those flows has its own limit per account or per device.
- APIs meant for machines, such as developer and partner APIs, get the same limits as the ones behind the app.
The 429 status code is defined in RFC 6585, which says the response may include a Retry-After header telling the client how long to wait.
Configuration and inventory (6 checks: API8 and API9)
- Every connection uses Transport Layer Security (TLS), including calls between internal services.
- Only the HTTP methods each endpoint needs are enabled, and cross-origin requests are allowed only from your own origins.
- Errors return a generic message, never a stack trace.
- An inventory lists every API host with its environment, who can reach it and which version it runs.
- Old versions have a retirement date, and non-production hosts either hold no production data or get production-level protection.
- Documentation is generated from the code in an open format and is visible only to people authorized to use the API.
Outbound calls and third parties (6 checks: API7 and API10)
- Any feature that fetches a URL from user input, such as a webhook, a file import or a link preview, uses an allow list of schemes, ports and hosts.
- Those fetches do not follow redirects, and the raw response is never passed back to the client.
- The service that does the fetching cannot reach internal addresses.
- Data received from third-party APIs is validated and sanitized like user input.
- Calls to third parties use TLS and have timeouts and size limits.
- Redirects from a third-party API are followed only to an allow list of known locations.
API security testing checklist: one test per area
An API security testing checklist turns each area into a request you can send and a result you can read. Five tests, one per area, catch the failures that matter most, and the first needs nothing more than two user accounts.
| Area | Test to run | Fails when |
|---|---|---|
| Authorization | Sign in as user B and request, change and delete user A's records by ID. | Any request succeeds. |
| Authentication | Send repeated wrong passwords, then an expired token, then a token with a changed signature. | Nothing slows down, or a bad token is accepted. |
| Limits and abuse | Ask for a very large page size and repeat a costly call in a loop. | The server does the work. |
| Configuration and inventory | Call an older version path and force an error. | The old version answers, or a stack trace appears. |
| Outbound calls | Give a URL-fetching feature an internal address. | It returns content from inside your network. |
Run these tests only against systems you own or have written permission to test, and start in a staging environment. The two-account test is worth automating first, because broken object level authorization is first on OWASP's list and a generic scanner cannot tell which records belong to which user.
Checking an API that an AI tool wrote
Start with the nine authorization checks. Code from an AI tool is usually tried out by one person signed in as themselves, and authorization failures do not show up in that kind of test.
The reason is structural. A generated endpoint that returns the right data for the signed-in user passes every check its builder is likely to make. The flaw appears only when a second user asks for the first user's record, and nobody asked the tool to build that test. The same goes for update endpoints that accept every field in the request: they work, and they also let a user change a field such as a role.
Our update on vibe coding security collects documented cases, including APIs that skip the authorization check so that one user can reach another user's records. For a quick first read of your own app, the vibe coding risk check asks 10 questions across security, data, payments and operations.
Standards behind an API security best practices checklist
An API security best practices checklist should point to documents a customer's security team already recognizes. Five cover most of what a small team needs, and all are public. The table gives each one's publisher and date as of November 2026.
| Document | Publisher, date | Use it for |
|---|---|---|
| API Security Top 10 | OWASP, 2023 edition | The shared list of risks |
| RFC 9700 | IETF, January 2025 | OAuth 2.0 security practice |
| RFC 8725 | IETF, February 2020 | Handling JSON Web Tokens |
| RFC 6585 | IETF, April 2012 | The 429 status code for rate limits |
| NIST SP 800-228 | NIST, June 2025, updated March 13, 2026 | API protection controls for cloud-native systems |
The NIST entry is the newest. NIST SP 800-228, Guidelines for API Protection for Cloud-Native Systems, was published in June 2025. NIST withdrew the original release on March 13, 2026 and replaced it with an update that adds two appendices. One lists API risks by category, and the other lists recommended security controls by API lifecycle stage. Cite the updated version.
For the code behind the API, as opposed to the API's behaviour, our guide to secure coding standards compares the documents that set requirements for the code itself.
When a checklist is not enough: an API security assessment
A checklist tells you whether the known controls exist. An API security assessment has a person read the code and the configuration, test whether the controls hold and rank what they find. Move from one to the other when the stakes rise.
Three situations usually call for an assessment:
- A customer or an auditor asks for evidence. A self-completed checklist is a starting point, and they will usually want a report from someone independent of the team that wrote the code.
- The API handles money, health data or other people's customer data. The cost of one missed authorization check is high enough to justify a second reader.
- Nobody on the team can answer the checks with confidence. Several "not sure" answers mean the knowledge is missing, and the gaps are probably wider than the checklist shows.
An assessment is also different from a penetration test. A code-level review sees every endpoint, including the ones no client calls yet, while a penetration test attacks the running system from outside. Our guide to penetration testing for startups explains when you need one and what it covers.
How we review API security
We read the code and the configuration, not only the running API. Our source code audit walks the endpoints against the five areas above and ends in a ranked list of findings with fixes. If an AI tool built the backend, the AI code audit starts with access control, data exposure, secrets and dependencies.
Every engagement is under an NDA, and the IP is always yours. Each one is quoted after a short call, because every codebase is different.
Frequently asked questions
What is an API security checklist?
An API security checklist is a list of yes-or-no checks that shows whether an API has the controls it needs. A useful one maps each check to a known risk, such as the OWASP API Security Top 10, and pairs it with a test. An answer of yes can then be shown, not only claimed.
What are the top 10 API security risks?
The OWASP API Security Top 10, 2023 edition, lists them: 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.
How do you test API security?
Start with five tests, one per area. Use two accounts to try reading another user's records, send bad passwords and bad tokens, request oversized pages, call old versions and force an error, and give any URL-fetching feature an internal address. Run them only on systems you own or have written permission to test.
Is the OWASP API Security Top 10 a standard?
No. OWASP describes it as an awareness document whose goal is to educate the people who build and maintain APIs. It ranks ten kinds of failure and does not define pass or fail. For requirements that software can be verified against, OWASP publishes the Application Security Verification Standard.
What is the difference between an API security assessment and a penetration test?
An API security assessment reviews the code, the configuration and the design, so it can see every endpoint and the logic behind each check. A penetration test attacks the running system from outside, as an attacker would. Assessments find causes, and penetration tests show what can be exploited. They answer different questions, so one does not replace the other.
Are API keys enough to secure an API?
No. OWASP states that API keys should not be used for user authentication, only to identify client applications. A key says which app is calling, not which person, and it cannot decide whether that person may see a given record. User authentication and per-object authorization checks are still needed.
How often should you run an API security checklist?
Run it before each release that adds or changes endpoints, and in full at least once a year. Automate what you can: the two-account authorization tests can run on every build. Review the checklist itself when a source document changes, as NIST SP 800-228 did in March 2026.
Sources and update history
- OWASP Top 10 API Security Risks, 2023
- OWASP API Security Top 10 2023, Introduction
- OWASP API Security Project
- OWASP API1:2023 Broken Object Level Authorization
- OWASP API2:2023 Broken Authentication
- OWASP API3:2023 Broken Object Property Level Authorization
- OWASP API4:2023 Unrestricted Resource Consumption
- OWASP API5:2023 Broken Function Level Authorization
- OWASP API6:2023 Unrestricted Access to Sensitive Business Flows
- OWASP API7:2023 Server Side Request Forgery
- OWASP API8:2023 Security Misconfiguration
- OWASP API9:2023 Improper Inventory Management
- OWASP API10:2023 Unsafe Consumption of APIs
- RFC 9700 (BCP 240), Best Current Practice for OAuth 2.0 Security (January 2025)
- RFC 8725 (BCP 225), JSON Web Token Best Current Practices (February 2020)
- RFC 6585, Additional HTTP Status Codes (April 2012)
- NIST SP 800-228, Guidelines for API Protection for Cloud-Native Systems (June 2025, includes updates as of March 13, 2026)
- NIST SP 800-228, original release (withdrawn)
- OWASP Application Security Verification Standard (project page)
Update history
- First published.
