API Security Checklist: OWASP Top 10 Explained
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.exein PowerShell (notcurl), 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
| Risk | In plain English | Quick test | Fix |
|---|---|---|---|
| API1 Broken Object Level Authorization | User A can open User B's records by changing an ID | Request B's ID with A's token | Check ownership on every request |
| API2 Broken Authentication | Login, tokens or password reset can be bypassed or guessed | Try many wrong logins, reuse old tokens | Rate limit logins, short-lived tokens, MFA |
| API3 Broken Object Property Level Authorization | The API shows or accepts fields users should not touch | Add role to a profile update | Allowlist fields in and out |
| API4 Unrestricted Resource Consumption | No limits on requests, size or cost | Send a small burst (about 30) of requests, ask for huge pages | Rate limits, size caps, pagination |
| API5 Broken Function Level Authorization | A normal user can call admin endpoints | Call admin URLs with a normal token | Deny by default, check role per endpoint |
| API6 Unrestricted Access to Sensitive Business Flows | Automation can abuse signups, coupons or purchases | Script a repeat of a valuable action | Limits, bot checks, step-up verification |
| API7 Server Side Request Forgery (SSRF) | The server fetches a URL an attacker chooses | Submit a URL you control, watch for a hit | Allowlist hosts, block internal addresses |
| API8 Security Misconfiguration | Debug modes, open CORS (the browser rule for which other websites may call your API), missing headers, verbose errors | Inspect headers and error messages | Harden defaults, review config |
| API9 Improper Inventory Management | Old or forgotten API versions and hosts still run | Look for /v1, docs and staging hosts | Keep a list, retire what you do not use |
| API10 Unsafe Consumption of APIs | You blindly trust data from third-party APIs | Review what you accept from partners | Validate 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:
- As User A, create an order and note its ID (say
1001). - 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
403or404on 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
roleor 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.
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