API Security Checklist: OWASP Top 10 Explained

By Bug Circuit Security Team
API Security Checklist: OWASP Top 10 Explained

Is your own website affected? Check it free in 2 minutes.

Passive outside check only. Nothing is attacked, no signup.

To check whether your API is safe, work through the OWASP API Security Top 10 in order of impact, starting with broken authorization: can one logged-in user read or change another user's data?

This post is for site owners and small dev teams who run an API (the part of your app that sends data to your website, mobile app or partners) and want to know what to check first. You will get a table of all ten risks with a quick test and a fix for each. You will also get a printable API security testing checklist, ordered by what to fix first.

One safety note before we start. Only test APIs you own, ideally on a staging copy, and use test accounts instead of real customer data.

What the OWASP API Security Top 10 is

OWASP (the Open Worldwide Application Security Project) is a nonprofit that publishes free security guidance. Its API Security Top 10 lists the ten most common and serious API risk categories. This post follows the 2023 edition, so check the OWASP site for any newer one.

It is not a law or a certificate. It is a shared checklist of mistakes that keep showing up in real APIs. If you cover these ten, you have covered the usual ground.

What you need before you test

  • Two test accounts with the same role (call them User A and User B).
  • One admin or higher-role test account, if your app has roles.
  • curl (built into macOS and Linux) or a tool such as Postman. On Windows, use curl.exe in PowerShell (not curl), run the commands in WSL or Git Bash, or use Postman.
  • A staging site, if you have one, so a mistake never touches real data.

You can copy a login token from your browser's developer tools (Network tab) while logged in as a test user. Treat tokens like passwords and never paste them into public chats or tickets.

The OWASP API Security Top 10 at a glance

RiskIn plain EnglishQuick testFix
API1 Broken Object Level AuthorizationUser A can open User B's records by changing an IDRequest B's ID with A's tokenCheck ownership on every request
API2 Broken AuthenticationLogin, tokens or password reset can be bypassed or guessedTry many wrong logins, reuse old tokensRate limit logins, short-lived tokens, MFA
API3 Broken Object Property Level AuthorizationThe API shows or accepts fields users should not touchAdd role to a profile updateAllowlist fields in and out
API4 Unrestricted Resource ConsumptionNo limits on requests, size or costSend a small burst (about 30) of requests, ask for huge pagesRate limits, size caps, pagination
API5 Broken Function Level AuthorizationA normal user can call admin endpointsCall admin URLs with a normal tokenDeny by default, check role per endpoint
API6 Unrestricted Access to Sensitive Business FlowsAutomation can abuse signups, coupons or purchasesScript a repeat of a valuable actionLimits, bot checks, step-up verification
API7 Server Side Request Forgery (SSRF)The server fetches a URL an attacker choosesSubmit a URL you control, watch for a hitAllowlist hosts, block internal addresses
API8 Security MisconfigurationDebug modes, open CORS (the browser rule for which other websites may call your API), missing headers, verbose errorsInspect headers and error messagesHarden defaults, review config
API9 Improper Inventory ManagementOld or forgotten API versions and hosts still runLook for /v1, docs and staging hostsKeep a list, retire what you do not use
API10 Unsafe Consumption of APIsYou blindly trust data from third-party APIsReview what you accept from partnersValidate third-party data like user input

API1: Broken Object Level Authorization (fix this first)

Object level authorization means the server checks that this user may access this specific record. When it is missing, anyone logged in can change an ID in the URL and see someone else's order, invoice or profile. OWASP ranks it first for a reason: it is common, and the damage is direct exposure of customer data.

Quick test:

  1. As User A, create an order and note its ID (say 1001).
  2. As User B, request it:
curl -i https://api.example.com/orders/1001 -H "Authorization: Bearer USER_B_TOKEN"

You want 403 Forbidden or 404 Not Found. A 200 with A's data means you have found a serious bug. Repeat for update (PUT, PATCH) and delete (DELETE) requests too.

Fix: on every request that touches a record, look it up with the logged-in user's ID, not just the record ID. For example, query WHERE id = 1001 AND owner_id = current_user. Do not rely on hard-to-guess IDs. Random IDs help a little, but they are not an access check.

API2: Broken Authentication

This covers anything that proves who a user is: login, tokens, password reset and API keys.

Quick test:

  • Send 20 wrong passwords for a test account. Does the API ever slow down, lock or return 429 Too Many Requests?
  • Log out, then reuse the old token. It should stop working. If you use stateless JWTs, tokens may stay valid until they expire, so keep their lifetime short.
  • Check that tokens expire. A token that lives for a year is a long-term risk if it leaks.
  • If you use JWTs (signed login tokens), confirm the server rejects a token with a changed signature.

Fix: rate limit login and password reset, keep access tokens short-lived, require multi-factor authentication for admin accounts, and never put API keys in URLs, where they end up in logs. The OWASP REST Security Cheat Sheet has practical detail.

API3: Broken Object Property Level Authorization

This is about individual fields. Two common forms: the API returns too much (a user object including password_hash or is_admin), or it accepts too much (called mass assignment).

Quick test: as a normal user, update your own profile with an extra field:

curl -i -X PATCH https://api.example.com/me -H "Authorization: Bearer USER_A_TOKEN" -H "Content-Type: application/json" -d '{"name":"Test","role":"admin"}'

Then fetch your profile. If role changed, that is a bug. Also read raw responses and look for fields the app never displays.

Fix: define exactly which fields each endpoint may accept and return. Do not pass raw request bodies straight into your database layer.

API5: Broken Function Level Authorization

Here the question is whether a user can call a function they should not, such as /admin/users or DELETE /products/5. Hiding a button in the app is not protection. The API itself must refuse.

Quick test: collect admin endpoints (from your docs or an admin's browser traffic), then call each with a normal user's token. Also try changing the method, for instance GET to DELETE.

Fix: deny by default. Every endpoint should state which roles may use it, and the server should enforce that on each call.

The rest of the list, briefly

API4, Unrestricted Resource Consumption. Without limits, one client can run up your hosting bill or knock your API over. Test by sending a burst of requests:

for i in $(seq 1 30); do curl -s -o /dev/null -w "%{http_code}\n" "https://api.example.com/search?q=test"; done

If all 30 return 200, ask whether that is acceptable. Thirty sequential requests may stay under a normal rate limit, so a passing result does not prove limits exist. Also test oversized page requests like ?limit=100000. Fix with rate limits, a maximum page size, upload size caps and timeouts. Only run this against your own API, and keep the burst small.

API6, Unrestricted Access to Sensitive Business Flows. The code works as designed, but a script can abuse it, such as mass account creation, coupon guessing or buying out limited stock. Think about which actions have real business value, then add limits per account and per device, and extra verification for risky steps.

API7, SSRF. If your API accepts a URL (webhooks, image imports, link previews), it may fetch addresses it should never reach, such as internal services or a cloud metadata endpoint (an internal address on cloud servers that can hand out credentials). Test by submitting a URL for a request-catcher service you control and see if your server calls it. Fix with an allowlist of permitted hosts and by blocking private and link-local ranges. On AWS, require IMDSv2. See OWASP's SSRF Prevention Cheat Sheet.

API8, Security Misconfiguration. Check what your API says about itself:

curl -I https://api.example.com/

Look for HTTPS only, a Strict-Transport-Security header, X-Content-Type-Options: nosniff, and Cache-Control: no-store on responses with private data. Trigger an error on purpose (send broken JSON) and make sure you do not get stack traces. Do not reflect any Origin back, especially with Access-Control-Allow-Credentials: true. A wildcard Access-Control-Allow-Origin: * is acceptable for a public API that does not use cookies or credentials. You can run a quick check of your site's headers with the security headers tool.

API9, Improper Inventory Management. Forgotten endpoints are unpatched endpoints. Look for old versions (/v1/), public docs such as /swagger.json or /openapi.json that you did not mean to expose, and staging hosts open to the internet. Keep a simple list of every API host and version, and switch off what is not used.

API10, Unsafe Consumption of APIs. Your API probably calls others (payments, shipping, CRM). Treat their responses like any other untrusted input: validate the shape and size, use HTTPS, set timeouts, and do not follow redirects blindly.

Cross-cutting API security best practices

These habits support all ten risks:

  • Use HTTPS everywhere, with no plain HTTP fallback.
  • Log failed logins and denied requests, and actually look at the logs.
  • Never put secrets (API keys, tokens) in front-end code or public repositories.
  • Keep frameworks and dependencies updated.
  • Return the same generic message for "wrong user" and "wrong password".

Printable API security testing checklist (fix in this order)

Print this, or paste it into your task tracker. The order is by usual impact, so start at the top.

1. Authorization (fix first)

  • [ ] Ownership is checked on every read, update and delete (API1)
  • [ ] Normal users get 403 or 404 on admin endpoints (API5)
  • [ ] Responses return only needed fields (API3)
  • [ ] Requests accept only allowlisted fields (API3)

2. Authentication

  • [ ] Login and password reset are rate limited (API2)
  • [ ] Tokens are short-lived and expire (and stop working after logout where the server can revoke them) (API2)
  • [ ] Admin accounts use multi-factor authentication (API2)

3. Abuse and cost

  • [ ] Rate limits, page size caps and upload limits are set (API4)
  • [ ] High-value actions have per-user limits (API6)

4. Server and exposure

  • [ ] User-supplied URLs are allowlisted and internal addresses blocked (API7)
  • [ ] Debug off, errors generic, security headers set, CORS locked down (API8)
  • [ ] Every API host and version is listed, and old ones are retired (API9)
  • [ ] Third-party API data is validated before use (API10)

Where a manual test goes further

The quick tests above catch the obvious problems. The top risks, especially API1, API3, API5 and API6, depend on how your app is meant to work, which is why scanners often miss them. A person has to understand who should see what. Our guide on manual vs automated penetration testing explains the difference, and is my website hackable? is a good next read if you want the wider picture.

Key takeaways

  • Test authorization first: use two accounts and see if User B can reach User A's data.
  • Add rate limits to logins and any expensive endpoint, and cap page and upload sizes.
  • Allowlist the fields your API accepts and returns, so users cannot set role or read hidden data.
  • Keep an inventory of every API host and version, and retire old ones.
  • Use the checklist above as a starting point, then have a person test the logic a scanner cannot understand.

Next step

If you would rather have an experienced person test this for you, a Bug Circuit audit is a manual test by a real security engineer, ending in a written report with every issue, evidence and fix steps. The Essential plan is $49 one-time and covers 1 website, including the API that site itself calls, with 3 audits to request within one month. Deeper API testing from your docs is available on Pro and Premium, and a separate API (such as a mobile app backend) is a standalone assessment with a fixed quote. This is a small-site audit, not a compliance certificate, and fixes are quoted separately only if you ask for them.

Want certainty, not guesswork?

A real human security engineer audits your whole site by hand and sends a full report: every issue, its severity, and the exact fix. From $49, with a 14-day money-back guarantee.

See pricing

Frequently asked questions

What is the OWASP API Security Top 10?
It is a free list from OWASP naming the ten most important API risk categories, such as broken authorization, broken authentication and unrestricted resource consumption. This post follows the 2023 edition. It works as a shared checklist for developers and testers, not as a certification.
What should an API security checklist include?
Start with authorization checks on every record and endpoint, then login and token protection, rate limits, field allowlists, safe handling of user-supplied URLs, hardened configuration and an inventory of all API versions. Each item should have a quick test, such as calling an endpoint with the wrong user's token.
How do I test my API for security issues?
Use two test accounts and a tool like curl or Postman on a staging copy. Try to read, change and delete one account's data from the other, call admin endpoints as a normal user, send extra fields in updates, and watch whether rate limits kick in. Only test APIs you own.
What are the most important API security best practices?
Check ownership on every request, enforce roles on the server, rate limit logins and costly endpoints, return only the fields you need, use HTTPS only and retire old endpoints. Authorization comes first because those flaws expose customer data most directly.
Is my API safe if it is behind a login?
Not automatically. A login proves who someone is, not what they may access. If the API does not check ownership on each record, any logged-in user may be able to see other users' data, so test that with a second account.

Keep reading

See what attackers see, for free

Run the free passive check on your website. No login, no impact on your site, results in seconds.

Ready for the full manual audit? See pricing

Published by Bug Circuit. Written with AI assistance and reviewed for accuracy before publishing.