API Vulnerability Assessment: A Complete Guide to Testing and Securing APIs


API security is not a final checklist item that can be added after an application is built. APIs expose data, business rules and operations to browsers, mobile applications, partner systems and other services. A weakness in an API can therefore bypass protections that exist only in the user interface. A user may be unable to view another customer’s order through the website but still be able to request it directly if the backend does not check ownership. A service may validate its own inputs carefully but trust a response from a third-party API that contains malicious or unexpected data.
An API vulnerability assessment is a structured process for discovering, validating, prioritising and helping remediate weaknesses in an API and the systems around it. It combines documentation review, threat modelling, configuration checks, automated testing and carefully controlled manual tests. The goal is not simply to run a scanner or produce a long list of findings. It is to establish whether each important API operation enforces the right identity, permissions, data boundaries and operational limits.
This guide explains how to plan an API vulnerability assessment, understand the major API security risks, test REST and other API styles safely, interpret findings and turn the results into an actionable remediation plan. It uses the OWASP API Security Top 10 2023 as a risk taxonomy. OWASP describes this as an awareness document for API-specific risks, not a substitute for a complete security programme. Always check the official project for the current edition and supporting guidance before an assessment.
An API vulnerability assessment evaluates whether an application programming interface can be abused to access data, perform actions, consume resources or reach systems beyond the permissions intended by its owners. It considers the API contract, implementation, identity model, business logic, deployment configuration and dependencies.
An assessment may cover public APIs used by customers, partner-facing APIs, internal service-to-service interfaces, administrative APIs, mobile application backends, webhooks and APIs exposed by cloud or container platforms. Internal does not automatically mean trusted. An internal endpoint can still be reached by a compromised service, an overly privileged employee account or an attacker who has gained a foothold in the network.
A vulnerability assessment is related to, but not identical to, a penetration test. An assessment can combine automated and manual checks to identify weaknesses and evaluate their risk. A penetration test generally goes further by attempting to exploit selected weaknesses within an agreed scope to demonstrate realistic impact. A secure code review examines implementation details directly. These activities overlap, and an organisation may combine them, but the report should state exactly what was tested and what was not.
A useful assessment examines several layers:
The result should connect a technical weakness to an affected endpoint, the conditions required to reproduce it, the data or operation at risk, and a practical remediation. A statement such as “authentication is weak” is not sufficient. A useful finding identifies the affected authentication flow, explains the missing control and demonstrates the consequence without exposing real user data.
Traditional web application testing often follows pages, forms and visible user journeys. API testing must examine the underlying operations directly. A frontend may hide a button from a basic user, but that does not prevent the user from sending the corresponding HTTP request. Authorization must be enforced by the server for every request, not inferred from which controls the interface displays.
APIs also expose identifiers and structured parameters. An endpoint such as GET /api/orders/1042 may accept an order identifier supplied by the client. The identifier is not proof that the caller owns the order. The server must derive the caller’s identity from a validated session or token and check whether that identity is allowed to access the specific order.
The same API may be consumed by several clients with different release cycles. A mobile app, browser frontend, partner integration and internal service can all depend on the same endpoint. A change that appears safe for one client may expose fields or permissions to another. Versioning, compatibility and inventory management therefore have direct security implications.
Finally, API risks frequently involve workflows rather than isolated requests. A single request to create an account may be harmless, while thousands of automated requests can enable fake-account creation or consume a paid verification service. A payment endpoint may validate each individual transaction but still allow an attacker to replay a request or manipulate the order of operations. Assessment must consider both individual endpoints and the business processes they enable.
Testing should begin with written authorisation and a clear scope. Do not scan or attempt to exploit an API merely because it is publicly reachable. Confirm who owns the system, who has approved the assessment, which environments may be tested and which activities are prohibited.
Collect the known API hosts, base paths, versions, environments and authentication methods. Include REST, GraphQL, gRPC, WebSocket interfaces, webhooks and administrative endpoints where relevant. Compare the inventory with OpenAPI descriptions, gateway configuration, application routes, service registries, cloud load balancers and observed traffic.
Record the business owner and technical owner for each API. Identify whether it handles personal information, financial data, credentials, health information, business-sensitive records or actions with financial consequences. Classify the sensitivity of the data and the impact of unauthorised access or disruption.
Do not assume the published API specification is complete. Specifications can be stale, omit internal routes or describe intended behaviour rather than deployed behaviour. The assessment should compare documentation with the running service and code where access is available.
Prepare accounts representing the roles that matter: unauthenticated visitor, ordinary user, account owner, support user, administrator and service identity. In multi-tenant applications, create at least two test tenants with separate records. This makes it possible to test whether one tenant can access another tenant’s objects without using real customer data.
Use synthetic records and credentials created specifically for the assessment. Define how test data will be cleaned up. Agree on rate limits and safe request volumes, especially when endpoints trigger email, SMS, payment, identity verification, file processing or other billable operations.
Document permitted hosts, IP ranges, test windows, request rates, test methods and emergency contacts. Explicitly identify prohibited actions such as destructive writes, denial-of-service testing, social engineering, persistence, access to real customer records or tests against third-party systems without separate permission.
Use a staging environment where it accurately represents production security controls. If production testing is required, keep it narrowly controlled and coordinate with the operations team. A test that creates, updates or deletes data should use dedicated records and an agreed rollback procedure.
Capture the API specification, response codes, authentication behaviour, normal request patterns and relevant configuration before testing. Record the date, application version, environment and test identities. This baseline helps distinguish an actual vulnerability from expected behaviour and makes retesting reproducible.
The OWASP API Security Top 10 2023 provides a useful structure for reviewing common API-specific risks. It should guide coverage, not become a claim that every API has exactly ten problems or that passing ten checks proves an API is secure.
Broken Object Level Authorization, often called BOLA, occurs when an API accepts an object identifier but does not verify that the authenticated caller is allowed to access that particular object. An attacker may change an order ID, invoice ID, profile ID or document ID and retrieve or modify another user’s record.
Test every operation that reads, updates, deletes or performs an action on an object identified by client-controlled input. Compare requests made by two separate test users and two separate tenants. Verify that the server checks ownership or an explicit sharing permission on every request. Random or unguessable identifiers can make enumeration harder, but they do not replace authorization.
A robust fix performs the access check in the backend data-access or service layer using the authenticated principal and the requested object. Tests should assert that a user cannot read, update, export or delete another user’s object, including through nested routes and bulk operations.
Broken authentication includes weaknesses in how the API establishes and maintains identity. Examples include accepting expired or incorrectly signed tokens, weak password-reset flows, insecure refresh-token handling, missing brute-force controls and credentials exposed in URLs or logs.
Review password and account-recovery flows, multi-factor authentication where appropriate, session expiry, token revocation, refresh-token rotation, issuer and audience validation, signing algorithms and key management. Check that API keys are scoped, stored securely, rotated and revocable. Do not treat an API key embedded in a mobile app or browser bundle as a secret.
A secure implementation uses well-maintained authentication libraries, validates token signatures and claims, applies suitable expiry and revocation controls, and protects credential-issuing endpoints against abuse. Authentication answers who is making a request; it does not establish what that identity is allowed to do.
This risk concerns access to individual fields or properties within an object. An API may return sensitive fields that a caller should not see, or accept fields that a caller should not be allowed to change. Examples include internal risk flags, account balances, role values, verification states or administrative properties.
Inspect response schemas and compare the fields returned to different roles. Submit unexpected properties in controlled update requests and verify that the server ignores or rejects fields the caller cannot modify. Use explicit request and response models rather than binding arbitrary JSON directly to database entities. Apply field-level access rules where different roles have different visibility or update permissions.
An API can be abused when it allows excessive requests, oversized payloads, expensive queries, unbounded pagination, uncontrolled concurrency or repeated operations that trigger paid services. The impact may include denial of service, degraded performance, storage exhaustion or unexpected costs.
Review per-user, per-client and per-endpoint rate limits. Check maximum request body sizes, file sizes, pagination limits, query depth and complexity, execution timeouts and concurrent job limits. Test only within the agreed request budget. Controls should be designed around the cost and sensitivity of each operation rather than applying one global limit to every endpoint.
Broken Function Level Authorization occurs when a user can invoke an operation outside their role or permission level. Examples include a standard user calling an administrative endpoint, changing another user’s account status or accessing an export function intended for support staff.
Build a role-to-operation matrix and test each sensitive function using the least privileged account. Do not rely on hidden routes, frontend visibility or HTTP method restrictions as authorization controls. Apply deny-by-default authorization on the server and verify permissions for every operation, including alternate routes and bulk actions.
Some endpoints are technically functioning as designed but expose business processes to automated abuse. Examples include purchasing limited inventory, creating trial accounts, reserving appointments, posting comments, redeeming promotions or requesting one-time codes at scale.
Identify flows where automation could harm users or the business. Consider rate limits, quotas, velocity checks, waiting lists, proof-of-work or bot detection, transaction limits and risk-based verification. CAPTCHA alone is not a complete solution, and controls should avoid unnecessarily blocking legitimate users or people who rely on assistive technology.
Server-Side Request Forgery, or SSRF, occurs when an API fetches a resource using a URL or destination influenced by a user without sufficiently validating where the server is allowed to connect. A vulnerable webhook tester, image importer, document preview service or URL-fetching endpoint may be manipulated into contacting internal services or cloud metadata endpoints.
Use an allowlist of permitted schemes, hosts and ports where possible. Resolve hostnames and validate the resulting IP addresses, account for redirects and DNS rebinding, and block loopback, private, link-local and metadata ranges at the network layer. Apply outbound network restrictions so that a compromised application cannot freely reach internal control planes. URL parsing and validation should use well-tested libraries rather than ad hoc string checks.
Misconfiguration can expose debug endpoints, stack traces, default accounts, permissive CORS rules, unnecessary HTTP methods, weak TLS settings or overly broad gateway policies. Review application, framework, reverse proxy, API gateway, container and cloud configuration across all environments.
Production errors should not reveal stack traces, file paths, database details or secrets. CORS should allow only the origins required by the application; it is not an authentication mechanism. Disable development tools and sample endpoints in production, keep dependencies patched and use repeatable secure configuration baselines.
An organisation cannot reliably protect APIs it does not know exist. Old versions, forgotten test hosts, shadow endpoints and undocumented administrative interfaces can remain reachable after the main application has moved on.
Maintain an inventory of hosts, routes, versions, owners, environments, data classifications and authentication requirements. Compare discovered endpoints with the approved specification. Define a deprecation process that includes communication, migration windows and actual shutdown. Ensure non-production environments are protected and do not contain production data or credentials unnecessarily.
An API that consumes data from another service must treat that data as untrusted. A compromised or unreliable upstream service can return malformed values, malicious content, unexpected redirects or responses designed to trigger injection flaws in the consuming application.
Validate third-party responses against expected schemas and business rules. Enforce TLS certificate validation, use timeouts and bounded retries, restrict redirect destinations where appropriate, and avoid blindly forwarding upstream data to clients. Apply the same output encoding and input validation principles used for direct user input. Maintain an inventory of integrations and assess their permissions and data-sharing arrangements.
A repeatable workflow keeps the assessment focused and makes findings easier to verify. The following sequence works for many REST APIs and can be adapted for GraphQL, gRPC and event-driven interfaces.
Start with the approved API specification, application documentation, gateway routes and a small amount of normal traffic. Identify methods, paths, parameters, request bodies, response types and authentication requirements. Group endpoints by business function and sensitivity.
Look for alternate versions, legacy routes, administrative paths, debug endpoints and endpoints used only by mobile or partner clients. Compare the documented routes with the deployed service. Mark unknown routes for owner review rather than assuming that every discovered route is in scope.
Map where identity is created, validated and propagated. Identify which service makes authorization decisions, which components can access databases, where files are stored, and which third-party systems are called. Document trust boundaries between browsers, API gateways, application services, background workers and external providers.
For microservices, verify that internal network location is not treated as sufficient proof of identity. Service-to-service calls should use authenticated identities and narrowly scoped permissions. A compromised low-privilege service should not automatically gain access to every internal API.
Use the agreed test identities to exercise each important route. Test unauthenticated access, expired credentials, invalid tokens, revoked tokens and insufficient permissions. Then compare access between users, roles and tenants.
Check both read and write operations. A route may correctly block a user from viewing another account while still allowing an update, export, deletion or status change. Include nested resources, batch endpoints, search filters and file-download routes in the review.
Review query parameters, path variables, headers, JSON bodies, multipart uploads and file metadata. Submit values that are missing, malformed, out of range, duplicated or of an unexpected type. Verify that the API rejects invalid input safely and does not reveal internal implementation details.
Test workflow rules using synthetic records. Check whether operations can be repeated, reordered or replayed; whether state transitions can be skipped; and whether totals, prices, ownership fields or status values can be manipulated. Avoid real payments or irreversible actions unless explicitly authorised and safely simulated.
Check rate limits, request size limits, pagination, query complexity, concurrency, timeouts and job queues. Use low-volume tests and coordinate with system owners. A successful assessment does not require overwhelming a service. Configuration review and controlled boundary tests can establish whether limits are present without creating an outage.
Inspect TLS settings, CORS policy, security headers, gateway rules, error handling, secrets management, dependency versions and deployment configuration. Review the API’s use of external services, webhooks, message brokers and file-processing components. Verify that credentials are not committed to source control or returned in API responses.
For each suspected weakness, repeat the test with a known-good control request and a test account that should be denied. Capture the minimal request and response evidence needed to demonstrate the issue. Remove or redact tokens, personal information and other secrets from evidence.
Distinguish confirmed vulnerabilities from observations and hardening recommendations. A scanner warning is not automatically a confirmed vulnerability; verify whether the affected component is reachable, whether the vulnerable configuration is active and what an attacker could actually do.
Prioritise findings by impact, exploitability, exposure, affected data and business context. Assign an owner and target date. After a fix, repeat the original test and run regression tests for related routes. Close a finding only when the security property is demonstrated, not merely because a code change was merged.
Authentication and authorization failures are among the most consequential API weaknesses. Keep the concepts separate: authentication establishes the identity associated with a request; authorization decides whether that identity may perform the requested action on the requested resource.
List the roles and important operations, then record the expected result for each combination. For example, a customer may read their own order but not another customer’s order; a support agent may view selected order details but not change payment ownership; an administrator may manage users but should still use a separately controlled privileged account.
Test positive and negative cases. Confirm that legitimate users retain access while unauthorised users receive an appropriate denial. A 403 or 404 response can be appropriate depending on the application’s disclosure policy, but the important property is that protected data and actions remain inaccessible.
Create two users and two tenants with clearly distinguishable synthetic records. Authenticate as the first user and request the second user’s object using its identifier. Repeat for read, update, delete, download and export operations. Check whether list and search endpoints can leak records through filters, counts or pagination metadata.
The application should enforce tenant and ownership constraints on the server. Filtering records only in the frontend is not sufficient. Where possible, enforce isolation close to the data access layer and add automated tests that attempt cross-tenant access.
Check token expiry, signature verification, issuer and audience validation, accepted algorithms, refresh-token rotation and revocation. Confirm that credentials are transmitted over HTTPS and are not placed in query strings. Inspect logs and error reports for accidental token exposure.
For OAuth 2.0 and OpenID Connect integrations, verify redirect URI matching, state and nonce handling where applicable, appropriate grant selection, and scope restrictions. Do not invent a custom token protocol when a maintained standard implementation is available. The correct configuration depends on the client type and threat model.
Input validation should enforce the API contract at the server boundary. Validate data types, allowed values, lengths, formats, numeric ranges and relationships between fields. Reject unexpected object structures rather than passing arbitrary client-controlled properties into database updates.
Use parameterized queries or safe query builders for database access. Avoid constructing SQL, NoSQL, shell commands, filesystem paths or regular expressions by concatenating untrusted values. Validate file uploads by checking size, content type and actual file structure; store uploads outside executable locations and apply malware scanning where the risk warrants it.
Review output fields as carefully as request fields. An endpoint should return only the properties required by the caller. Avoid exposing internal identifiers, password hashes, reset tokens, private notes, access-control flags or administrative metadata. Apply consistent serialization rules and test responses for each role.
For GraphQL, review resolver-level authorization, query depth and complexity limits, batching behaviour, introspection exposure and error details. A schema can make an API easier to explore, but schema visibility does not replace authorization. For gRPC, review service and method permissions, message validation, transport security and reflection settings. For webhooks, verify signatures, timestamps, replay protection and the handling of duplicate deliveries.
API security depends on the surrounding infrastructure as well as application code. Verify that TLS is enforced for external traffic and that internal service connections are protected according to the environment’s risk. Review certificate validation and renewal, gateway authentication, allowed methods, request-size limits and upstream routing.
CORS controls which browser origins may read responses; it does not stop non-browser clients from sending requests and should not be treated as access control. Avoid wildcard origins when credentials are involved. Set only the methods and headers required by trusted browser clients.
Error handling should provide clients with useful but limited information. Return stable error formats and correlation identifiers, while keeping detailed stack traces and diagnostic context in access-controlled logs. Logs should record security-relevant events such as failed authentication, denied access, privilege changes and suspicious request patterns. They should not record passwords, access tokens, private keys or full sensitive payloads.
Secrets should be stored in an appropriate secrets manager or protected runtime configuration, not hardcoded in source files, container images or frontend bundles. Restrict access, rotate credentials when exposure is suspected and remove unused keys. Apply least privilege to database accounts, cloud identities, message brokers and background workers.
Review deployment environments separately. Staging and preview systems can expose older code, debug modes or test credentials. Ensure that non-production APIs are access-controlled, inventoried and kept separate from production data. Retire old versions instead of leaving them online indefinitely.
Tools help make testing consistent, but no single scanner can determine whether an API correctly enforces every business rule. Select tools based on the API style, the assessment scope and the evidence required.
| Tool or resource | Typical use | Important limitation |
|---|---|---|
| OWASP ZAP | Intercepting traffic, passive analysis and authorised active testing | Needs suitable API definitions and authenticated context; business logic still requires manual review |
| Burp Suite | Proxying requests, replaying and modifying traffic, manual testing | Requires careful scope configuration and tester judgement |
| Postman or Insomnia | Sending documented requests and maintaining collections | Functional collections are not a complete security assessment |
| OpenAPI or Swagger tooling | Reviewing API contracts and generating test inputs | A specification may be incomplete or differ from the deployed service |
| Nuclei | Template-based checks against known exposures and misconfigurations | Templates must be reviewed and run only against authorised targets |
| Dependency scanners | Identifying known vulnerable libraries and packages | A vulnerable dependency is not proof that an exploitable path exists |
| Secret scanners | Finding credentials accidentally committed to repositories | Findings require validation, rotation and cleanup |
| Logs and observability platforms | Correlating suspicious activity and confirming control behaviour | Logging cannot replace preventive authorization and validation |
Use a proxy such as ZAP or Burp to understand requests and responses, replay controlled test cases and compare behaviour between roles. Import an OpenAPI document where possible, but confirm that the routes in the document match the deployed application. Use dependency and secret scanners as supporting checks within the development pipeline.
For manual work, a request collection with named environments and test identities can improve repeatability. Keep secrets out of exported collections and source control. Store evidence securely and remove sensitive data before sharing reports. Tools should be configured to avoid destructive payloads, excessive concurrency and requests outside the approved scope.
A useful report explains risk in terms that developers, security teams and business owners can act on. Include a concise title, affected host and endpoint, environment, affected role, prerequisites, reproducible steps, observed behaviour, expected behaviour, impact, evidence, severity rationale and recommended remediation.
Prioritise using more than a generic scanner score. Consider whether the API is internet-facing, whether authentication is required, what data or operations are exposed, how many users or tenants are affected, whether exploitation is reliable and whether compensating controls exist. A low-complexity authorization flaw on a public endpoint that exposes sensitive records may deserve more urgent attention than a theoretical issue on an isolated test service.
A clear finding might state: “A user authenticated as Tenant A can retrieve an invoice belonging to Tenant B by changing the invoice identifier in the request. The endpoint checks that the caller is logged in but does not verify tenant ownership. The test used synthetic invoices and did not access customer data.” This is more useful than simply labelling the issue “IDOR.”
Separate confirmed vulnerabilities from observations, informational notes and recommendations. Record endpoints and test cases that were not assessed, including reasons such as unavailable test accounts or out-of-scope dependencies. State the limitations of automated coverage and whether testing was performed against staging or production.
Avoid including live credentials, unredacted tokens, customer records or exploit payloads that could be reused outside the authorised context. Provide enough evidence for the owner to reproduce the issue safely, and keep more sensitive technical detail in a controlled report if necessary.
Remediation should address the underlying security property rather than only the example request. If one endpoint has a BOLA issue, search for the same authorization pattern in related endpoints. If a response leaks sensitive fields, review shared serializers and other routes that use the same model.
Prefer centralised, well-tested authorization policies where they fit the application architecture. Enforce permissions on the server and close to the resource being accessed. Use explicit data-transfer objects or allowlists for writable fields. Validate external input at service boundaries and treat data from upstream APIs as untrusted.
Add regression tests for every confirmed finding. Tests should verify both that the attack is blocked and that legitimate access still works. Include role and tenant combinations, expired or revoked credentials, invalid state transitions, rate-limit boundaries and malformed input as appropriate.
Integrate security checks into the software delivery lifecycle. Validate API specifications, scan dependencies and secrets, run static analysis, test authorization rules and perform dynamic checks in controlled environments. Review significant API changes during code review, especially new routes, new object identifiers, new writable properties, new integrations and changes to authentication or permissions.
Maintain an API inventory and assign owners. Review it during architecture changes, acquisitions, service migrations and decommissioning. Monitor for unexpected endpoints, unusual authentication failures, access-denied spikes, high request rates and abnormal use of sensitive business flows. Alerts should have owners and response procedures; collecting logs without acting on them does not create an effective control.
Security is continuous because APIs, clients, dependencies and business workflows change. Schedule reassessments based on exposure and risk, and repeat targeted testing after significant changes or incidents. Use assessment results to improve design standards and developer training rather than treating each report as an isolated exercise.
Testing only the frontend. A browser interface may hide controls, but attackers can call the API directly. Test the server-side endpoints independently.
Checking authentication but not authorization. A valid token proves identity, not ownership of every object or permission to invoke every function. Test roles, object ownership and tenant boundaries separately.
Relying on random identifiers. UUIDs can reduce guessing but do not prevent a user who obtains another identifier from accessing the corresponding object. Enforce authorization on every request.
Trusting the API specification as complete. Documentation may omit legacy, internal or administrative routes. Compare it with deployed routes and gateway configuration.
Running scanners without authenticated coverage. Unauthenticated scans often miss protected operations and role-specific behaviour. Use approved test accounts and manual checks for business logic.
Treating rate limiting as the only abuse control. Sensitive workflows may need quotas, velocity checks, transaction controls, anomaly detection and business-level safeguards.
Ignoring upstream services. Third-party APIs and webhooks can return untrusted data. Validate responses, verify webhook authenticity and constrain outbound requests.
Testing without safety boundaries. Aggressive scans can send email, create real transactions, modify records or disrupt a service. Agree on scope, test data, request budgets and rollback procedures first.
Closing findings after a code change without retesting. A merged fix is not evidence that the vulnerability is resolved. Repeat the original test and add regression coverage.
Use this checklist to structure an assessment and record evidence. Adapt it to the API’s architecture and risk; not every item applies to every service.
It is a structured review of an API’s security controls, implementation and deployment. It looks for weaknesses such as broken authorization, insecure authentication, excessive data exposure, injection, resource exhaustion, SSRF and unsafe integrations. It should produce prioritised findings and evidence that owners can use to fix and verify the issues.
An assessment may use documentation review, automated tools and manual tests to identify and evaluate weaknesses. A penetration test attempts to exploit selected weaknesses within an agreed scope to demonstrate practical impact. The terms are sometimes used interchangeably, so confirm the exact methods and deliverables before an engagement.
There is no universal answer for every system, but authorization deserves particular attention. The OWASP API Security Top 10 2023 places Broken Object Level Authorization first and includes several other authorization-related risks. Test whether each identity can access only the objects, fields, functions and workflows it is permitted to use.
No. Automated tools can identify known patterns, exposed services, configuration issues and some input-handling flaws. They cannot reliably infer every business rule, tenant boundary or intended permission. Combine automation with manual testing, code review and tests using realistic roles and synthetic data.
Assess APIs before significant releases and after material changes to authentication, authorization, data models, integrations or infrastructure. Higher-risk and internet-facing APIs may warrant more frequent testing and continuous monitoring. The schedule should reflect exposure, sensitivity and change frequency.
Not necessarily. Internal APIs may be reachable through compromised workloads, misconfigured networks, stolen service credentials or overly broad access. Authenticate service identities, restrict permissions and network paths, and apply authorization and input validation to internal endpoints as well.
HTTPS protects data in transit and helps authenticate the server when configured correctly. It does not prevent broken authorization, insecure business logic, excessive data exposure, weak token handling or unsafe server-side requests. Transport security is essential but only one part of API security.
Include scope, methods, environment, affected endpoints, test roles, reproducible steps, observed and expected behaviour, impact, evidence, severity rationale, remediation and retest status. Clearly document exclusions and limitations, and redact credentials and personal information.
Use primary documentation when designing controls or validating an assessment. The OWASP API Security Top 10 is an awareness framework; the OWASP testing guides and project resources provide additional material for planning and executing security tests.
For related background, read the guide to what an API is and how APIs work, the article on API design fundamentals, and the guide to microservices architecture.

Learn what APIs are, how web APIs work, and how to design, secure, document, test and build reliable APIs with practical examples.
Read
Learn the principles of API design, from resource modeling and HTTP semantics to pagination, error handling, authentication, security, versioning, documentation, testing, and observability, with practical examples.
Read
Learn practical API design with FastAPI, from REST resources and Pydantic validation to authentication, pagination, versioning, testing, performance, security, and production deployment.
Read