
API-related issues accounted for 43% of additions to the U.S. CISA Known Exploited Vulnerabilities catalog in Wallarm's analysis reported by SecurityWeek. That reframes API security standards as an exploitation problem, not just a documentation exercise. For a penetration tester, the useful question isn't whether a customer has adopted a standard. It's which unauthorized request the implementation rejects, and what evidence proves that rejection.
Table of Contents
- API Security Standards at a Glance
- How the OWASP API Top 10 Changed Since 2019
- Authorization Flaws Standards Catch First
- OAuth and OpenID Connect Checks That Hold Up
- Transport, Input, Rate and Logging Controls to Verify
- Mapping Standards to PCI DSS, SOC 2 and ISO 27001
- Choose Your Testing Approach and Confirm Authorization
API Security Standards at a Glance
Core API security standards and what testing verifies
| Standard | Governs | Core requirement | What a pentest verifies |
|---|---|---|---|
| OWASP API Security Top 10 (2023) | API risk categories | Authorization per object and function, resource limits, inventory | Object ID swaps, function access, resource abuse |
| OAuth 2.0 Security BCP (RFC 9700) | Token issuance and authorization flows | PKCE for public clients; no implicit grant as the default security baseline | Code redemption without a verifier; unintended implicit-flow enablement |
| OpenID Connect Core 1.0 | Identity and login claims | Validated ID tokens | Signature, issuer, audience, and nonce checks |
| TLS (RFC 8446, RFC 9325) | Transport encryption | TLS 1.2 minimum, TLS 1.3 preferred, strong ciphers | Protocol downgrade, weak cipher suites, certificate validation |
| NIST SP 800-204 | Service-to-service and microservice APIs | Authenticated service communication and enforced access policies | Untrusted service calls, policy bypass, inconsistent enforcement between services |
APIs accounted for 57% of dynamic Internet traffic in Cloudflare's 2024 API Security and Management Report, based on global traffic observed from October 2022 through August 2023. Web-page controls alone don't establish whether a machine client can retrieve another tenant's records, misuse a token flow, or invoke an internal operation directly.
Use the table as a routing decision. Start with the standard your customer, contract, or assessor names, identify the relevant implementation, and attach a negative test to it. An identity-provider configuration review and an object-authorization test answer different questions, even when they examine the same application.
Turn references into test cases
For each selected requirement, record the target, preconditions, prohibited action, expected result, and evidence. Include the endpoint version and client registration where relevant. Otherwise, a passing result can become detached from the configuration it tested.
The OWASP Application Security Verification Standard guide provides a useful companion for organizing application-level verification requirements. Use that broader structure alongside API-specific cases, rather than treating either document as a substitute for an executable test plan.
Standards also serve different purposes. OWASP supplies a risk taxonomy, protocol specifications define implementation behavior, and architecture guidance helps place enforcement boundaries. None automatically supplies a complete penetration-testing scope.
Practical rule: A standard is a list of requirements. Only a test shows whether a requirement actually holds.
How the OWASP API Top 10 Changed Since 2019
Consider an order-management API with customer records, support operations, and a shipping integration. A general web checklist might emphasize injection and session management. An API-focused assessment must also examine who can retrieve each order, which fields callers can edit, and what the application trusts from the shipping service.
The first OWASP API Security Top 10 edition was presented at OWASP Global AppSec Tel Aviv in May 2019 and named ten priority categories: broken object-level authorization, broken user authentication, excessive data exposure, insufficient rate limiting, broken function-level authorization, mass assignment, security misconfiguration, injection, improper asset management, and insufficient logging and monitoring.
The timeline captures that move toward a dedicated API risk taxonomy.

From individual payloads to complete workflows
Four years later, OWASP developed its 2023 edition using public API incident reports from 2019 through 2022, a three-month public data call from September 1 through November 30, 2022, and its Risk Rating Methodology, as described in OWASP's account of the update. The revision still contains ten categories, but the changes affect what assessors should attempt.
- Property boundaries: Excessive Data Exposure and Mass Assignment merged into Broken Object Property Level Authorization. For the order API, reading an internal fraud flag and changing that flag are related failures of field-level policy.
- Business-flow abuse: Unrestricted Access to Sensitive Business Flows adds the question of whether permitted operations can be automated or sequenced harmfully.
- Integration trust: Unsafe Consumption of APIs introduces an explicit focus on what happens when the shipping integration returns malicious or unexpected content.
The current list also covers Broken Object Level Authorization, Broken Authentication, Broken Function Level Authorization, SSRF, Security Misconfiguration, and Improper Inventory Management. Don't interpret that continuity as an unchanged category-by-category mapping: SSRF wasn't a standalone category in the original list.
For a service provider, the practical change is scope. Testing isolated requests won't establish whether a workflow is abuse-resistant or whether a downstream dependency can cross a trust boundary.
Map every category to a real asset in the customer's inventory. Assign an endpoint, resolver, integration, or workflow, and explicitly mark categories that have never been tested rather than treating missing results as passing coverage.
Authorization Flaws Standards Catch First
A valid login doesn't establish permission to access a particular record. Say customer A retrieves order 1043, then requests order 1044 using the same token and receives customer B's delivery address. Authentication worked. Authorization failed.
The distinction matters because three of the five highest-ranked risks in the OWASP API Security Top 10:2023 concern authorization: Broken Object Level Authorization, Broken Object Property Level Authorization, and Broken Function Level Authorization.
The diagram separates caller identity from the permission decisions that must follow it.

Separate object, property, and function boundaries
Broken Object Level Authorization, or BOLA, occurs when the server accepts a caller-supplied identifier without checking access to that object. Identifiers can appear in paths, query parameters, headers, or request bodies. Don't limit the test to the most visible URL parameter.
Broken Object Property Level Authorization concerns fields within an otherwise accessible object. A customer might legitimately view an order but shouldn't receive internal investigation notes or change its settlement status. Test response exposure and write permissions separately.
Broken Function Level Authorization occurs when a lower-privileged caller can invoke a restricted operation. Replaying a support-only refund request with a customer token tests a different boundary from reading another customer's order.
Consequences include cross-tenant disclosure, modification, deletion, and potentially account takeover. The server therefore needs an authorization decision for every object access, exposed or writable property, and privileged function. Randomized identifiers help resist discovery, but they aren't permission checks.
Build an authorization matrix
Use principals from different tenants and roles, with known-owned test records. Capture a permitted baseline, then change only the dimension under examination so the result remains interpretable.
- Object replay: Preserve the token and request structure while substituting another principal's object identifier.
- Property mutation: Add restricted JSON fields and verify whether they persist, including when the response claims rejection.
- Function replay: Invoke an administrative operation with a lower-privileged token and inspect downstream effects.
- Evidence comparison: Retain sanitized request pairs, response bodies, record ownership, and before-and-after state.
A denial status alone isn't enough. A handler can return an error after updating a record or scheduling a background task. Verify persistence, queued work, and administrative side effects using the test fixtures.
This video provides another way to examine API authorization risks.
Centralized policy and hierarchy-aware authorization make these rules easier to review, but enforcement must reach the data-access path. Keep the replay cases as automated regression tests, with policy expectations written explicitly. A scanner cannot infer a customer's tenant-sharing rules from response codes alone.
OAuth and OpenID Connect Checks That Hold Up
Start with the flow, not the token's appearance. A correctly signed token doesn't establish that the authorization code was delivered safely, that the intended client redeemed it, or that the resource server enforces its binding.
RFC 9700, the OAuth 2.0 Security Best Current Practice, requires PKCE for public clients and recommends it for confidential clients. PKCE protects against authorization-code interception and injection and can also mitigate cross-site request forgery. Use a challenge method that doesn't expose the verifier in the authorization request, and publish supported methods in authorization-server metadata.
The flowchart highlights the relationship between protocol review and code-interception protection.

Execute the negative cases
Avoid the implicit grant unless token-injection and leakage risks are explicitly mitigated. For higher-assurance deployments, consider sender-constrained access tokens using mutual TLS or Demonstrating Proof of Possession, commonly called DPoP. Those mechanisms require operational work around certificates or proof keys, but they make stolen tokens materially harder to replay independently.
- Enumerate public-client flows. Confirm PKCE enforcement for each registration, not merely the primary application.
- Break code redemption. Submit a code without a verifier and with a mismatched verifier. Neither attempt should issue tokens.
- Compare metadata with behavior. Check that advertised challenge methods match what the authorization endpoint accepts.
- Probe unintended grants. Test whether a client still accepts an implicit response type despite the documented migration.
- Verify possession at the resource server. Replay a sender-constrained token without its legitimate certificate or proof key.
Preserve the authorization request, altered redemption request, sanitized response, and relevant client configuration. For proof-of-possession testing, record why the replay lacked the required binding. Otherwise, an expired token could produce a misleading pass.
Validate identity claims separately
For OpenID Connect, test ID token signature, issuer, audience, and nonce validation at the relying party. Use controlled negative tokens and confirm rejection before a login session is established. Don't treat an ID token as an interchangeable API access credential.
A useful evidence record distinguishes code-flow protection, identity validation, and resource-server enforcement. Passing one doesn't imply that the others work, and a gateway's token check doesn't prove the application's login implementation is sound.
A common migration mistake is enabling PKCE in the single-page app while leaving an old implicit client registration active. Test every client registration, including mobile, partner, legacy, and nonproduction registrations that can reach the scoped environment.
Transport, Input, Rate and Logging Controls to Verify
Authorization testing doesn't replace baseline hardening. Use a control table to define the expected behavior before generating traffic, especially when customers share gateways or infrastructure.
Baseline API controls, minimum settings and tests
| Control | Minimum expected | Test to run | Evidence to keep |
|---|---|---|---|
| TLS | TLS 1.2 floor, TLS 1.3 where supported, HSTS for browser clients | Protocol downgrade attempt, cipher scan | Scan output listing accepted protocols |
| Input validation | Schema, type and length limits | Malformed JSON, oversized bodies, injection payloads | Rejected requests and error responses |
| Rate limiting | Per-client and per-endpoint limits on login and costly queries | Burst of login attempts and heavy queries | 429 responses and back-off timing |
| Logging and monitoring | Authentication failures, access denials, and admin actions logged | Trigger failed logins, check alerting | Log entries with timestamps and alert IDs |
Verify enforcement at the actual boundary
Use testssl.sh or an equivalent protocol scanner to examine accepted protocols, cipher suites, and certificate handling. Include upstream service connections where they're in scope. HSTS helps browser clients, but it doesn't force a machine client to validate certificates or prevent a caller from attempting plaintext HTTP.
For input handling, use Burp Suite Repeater or schema-driven tests to submit malformed JSON, excessive nesting, oversized bodies, unexpected fields, and injection payloads. Rejecting malformed input isn't proof against injection: inspect how valid-looking values reach queries and commands, and use parameterized database operations rather than relying on validation alone.
Rate-limit testing needs an agreed ceiling and stop condition. Exercise login, password reset, and expensive queries, then verify 429 responses and effective back-off, not just a configured gateway policy. Kogifi's guidance on how to protect enterprise APIs with rate limits is useful when choosing enforcement keys and endpoint-specific policies.
A control without evidence is an assumption. Keep the scan output, rejected requests, throttling responses, and alert identifiers in the same ticket as the finding.
Test what baseline controls miss
Trigger authentication failures and access denials, then confirm that logs contain timestamps, caller identity, and correlation information without leaking credentials. Check that the intended alert reaches its destination. Collecting an event and notifying a responder are separate outcomes.
Business-flow tests should exercise checkout, coupon redemption, and account recovery as sequences, within agreed transaction limits. A caller can remain below a request threshold while violating a business rule through ordering or repetition.
For third-party consumption, use a controlled mock integration to return unexpected fields, invalid types, and malicious content. Verify validation before the application stores, renders, or acts on that content, and retain evidence of rejected downstream effects.
Mapping Standards to PCI DSS, SOC 2 and ISO 27001
Framework requirements and the API evidence they expect
| Framework | API-relevant requirement | Evidence to keep |
|---|---|---|
| PCI DSS v4.0.1 | Requirement 11.4, penetration testing of applications and networks | Scoped test reports, remediation records, and retest results |
| SOC 2 | CC6 logical access, CC7 monitoring | Access review results and monitoring alerts |
| ISO/IEC 27001:2022 | Annex A 8.25, secure development; 8.29, security testing | Test plans, results, and risk treatment records |
| HIPAA Security Rule | Evaluation under 45 CFR 164.308(a)(8) | Evaluation records after environmental or operational change |
| GDPR | Article 32, security of processing | Tested safeguards for personal data APIs |
These are control crosswalks, not interchangeable certifications or a universal testing scope. Applicability depends on the organization, system boundary, processing activities, and assessment arrangements. An API penetration test contributes evidence; it doesn't establish compliance by itself.
For PCI reporting terminology, Yellow.ai's explanation helps teams compare AoC, RoC, and SAQ before choosing the right documentation workflow. Keep that choice separate from deciding which attack paths require technical testing.
Configuration isn't attack resistance
In an analysis of 60 API breaches disclosed in 2025, Wallarm attributed 52% to broken authentication and 27% to unsafe consumption of APIs. Those findings support examining identity and integration behavior rather than accepting configuration screenshots as sufficient assurance.
Attach each applicable requirement to a repeatable negative test, a named owner, the evidence produced, and the residual risk. A compliance matrix can maintain those relationships without duplicating the same technical evidence across customer questionnaires.
Say a SOC 2 auditor asks how tenant isolation is tested. A useful answer is a dated cross-tenant BOLA run with known-owned records, paired requests, denied responses, and persistence checks saved to the control record. A screenshot showing OAuth enabled doesn't answer that question.
Evidence boundary: Record what the test established and what it didn't. A passing REST endpoint test doesn't establish equivalent isolation in GraphQL resolvers or background exports.
The control owner should record exclusions such as untested delegated access, service-to-service paths, or agent-used credentials. Authentication strength and authorization correctness remain distinct, even where mTLS establishes a strong caller identity.
Repeat relevant tests whenever endpoints, scopes, or data models change, not only during the annual audit. Each rerun should add a dated entry to the same evidence file, including the deployed version, result, remediation status, and accepted exceptions.
Choose Your Testing Approach and Confirm Authorization
Manual testing is the better fit for business logic, ambiguous policies, and chained flaws. A specialist can investigate whether a permitted export exposes identifiers that become useful elsewhere. The trade-off is constrained coverage and a need to turn exploratory work into reproducible cases.
Automated testing provides breadth, speed, and repeatable regression. It works well for known negative cases, schema handling, and configuration drift, but its results depend on authenticated coverage and clear assertions. A job that never reaches protected operations can finish successfully without testing the customer's important risks.
Use a hybrid delivery model
A hybrid approach lets automation cover the baseline while specialists investigate authorization and business logic. For service providers, that division makes review effort easier to prioritize. The API penetration testing guide can help organize the engagement around endpoints, credentials, trust boundaries, and reporting.
Before any traffic is generated, confirm authorization for every target. Accepted authorization documents include ownership records, a signed authorization or rules-of-engagement document, or domain or asset control validation. We require customers to confirm and attest that they're authorized to test the specified targets and scope.
Ownership of an application doesn't automatically authorize testing its suppliers. Customers may not test third-party infrastructure or services, including cloud, hosting, telecom, or SaaS providers, without complying with those providers' testing policies and obtaining any required authorization.
Make the first engagement reproducible
The rules of engagement should identify permitted environments, destructive-action restrictions, load ceilings, emergency contacts, and stop conditions. Use synthetic records where possible, and agree how sensitive evidence will be redacted, stored, and delivered.
- Assign control ownership. Map each standard in scope to a person responsible for implementation and remediation.
- Collect authorization documents. Cover every target and resolve provider-policy requirements before execution.
- Run authorization and token tests. Use separate principals with known ownership and role differences so results have clear meaning.
- Retest each fix. Preserve the original case, remediation details, and dated evidence of the new behavior.
Our reports include evidence, screenshots, and compliance-ready documentation for standards such as PCI-DSS, SOC2, and ISO 27001. Regardless of reporting format, distinguish verified findings from coverage gaps and residual risk. Security testing cannot identify every vulnerability.
Pick one standard this week and run one authorized negative test against it. Start with the BOLA replay: use customer A's token against customer B's synthetic order, verify that no data or state change crosses the boundary, and save the request pair as a regression case.
ThreatExploit AI offers automated penetration testing for security service providers, including REST and GraphQL API targets and evidence-backed, compliance-mapped reporting. Visit ThreatExploit AI to explore how authorized, repeatable API testing can support your customer assessments and remediation workflow.