Cybersecurity credentials
NCA registration
Registered cybersecurity service provider

ISO/IEC 27001
ISO/IEC 27001 certified
Why APIs test differently
The interface no longer hides anything
A server-rendered application controls what the user can attempt: the button is not there, so the request is not made. An API has no such property. Every endpoint is callable by anyone who can authenticate, in any order, with any parameter value, and the client is an implementation detail the caller can replace. Controls that existed only in the front end are therefore not controls at all — which is the single most productive assumption a tester can start from.
That shifts where the bugs are. Injection classes are largely handled by mature frameworks and parameterised queries; they still appear but they are no longer where the impact concentrates. Authorisation is different, because it cannot be solved by a framework — every endpoint has to decide whether this caller may act on this object, and that decision is made by hand, hundreds of times, by different people over several years. It is the definition of a control that degrades.
The practical consequence for how a test is run: the time goes into building an accurate picture of endpoints and roles, then executing a matrix. A tester who spends day one on injection payloads and day four on authorisation has the sequence backwards, and a report dominated by header and TLS findings usually indicates a test that never got past the tooling.
Method
Six stages, in the order that finds the most
1 · Build the real inventory
Never scope from the specification alone. Combine it with proxied traffic from every client, strings and endpoint references extracted from mobile binaries, gateway route configuration, and historical routes still answering. The endpoints that are not in the specification are disproportionately likely to be the vulnerable ones, because nobody reviewed them. An endpoint list with method, parameters and which client calls it — including the ones nobody expected.
2 · Map identities and roles
Obtain credentials for every role, plus two accounts within the same role — the second is what makes horizontal object-level testing possible at all. Also test as an authenticated user with no role assignment and as an anonymous caller, which are frequently forgotten states. A role matrix with working credentials and the intended permission for each combination.
3 · Object-level authorisation, systematically
For every endpoint taking an identifier, replay the request as a different account and as each role, substituting an identifier the caller should not own. Automate the replay and diff the responses — a 200 where a 403 was expected is the finding, and so is a 404 whose timing or body differs from a genuine miss. A matrix of endpoint against role with the observed versus intended outcome in each cell.
4 · Function-level authorisation and method confusion
Call administrative endpoints as a low-privileged role. Then vary the method — an endpoint that authorises GET correctly and not DELETE is common where authorisation is applied per handler rather than per route. Try undocumented methods and path variations that may bypass a gateway rule matched on an exact string. Privileged functions reachable from an unprivileged session, with the exact request that reaches them.
5 · Business logic and workflow
The manual stage that no tool replaces. Call a multi-step workflow out of order, skip the step that performs validation, replay a state transition that should be terminal, submit negative or extreme values where the client constrains the range, and run two requests concurrently against the same object to find the race the application assumed could not happen. Abuse cases with the business consequence stated, not just the anomalous response.
6 · Everything else, then retest
Token handling, mass assignment, data exposure, rate limits, injection classes and third-party integration paths — covered below. Then verify the fixes, including that a fix in one place was applied everywhere the same pattern occurs. A retest note per finding stating fixed, partially fixed or unchanged, with evidence.
The other classes
What else the assessment has to cover
Authorisation carries the impact, but a test that covers only authorisation is incomplete. Each of these has a specific way it is found rather than a definition.
Token and session handling
Check signature verification is enforced rather than assumed — a token with the algorithm changed, or an unsigned token, should be rejected. Check expiry is validated server side, that a logout or a password change invalidates existing tokens, and that a refresh token cannot be replayed after use. Long-lived tokens with no revocation path are a design finding, not a configuration one.
Mass assignment
Send fields the client never sends. A user-profile update that binds the request body directly to the model will frequently accept a role, tenant, balance or verified flag. Read the response of a GET on the same object to discover the field names worth trying — the API usually tells you its own schema.
Excessive data exposure
Compare what the endpoint returns against what the client displays. Filtering in the front end is the pattern here: the object contains an identity number, an internal note or another user's details, and the interface simply does not render them. Check error responses and pagination metadata too, which are often serialised from a different, unfiltered path.
Rate limits and resource consumption
Test whether limits apply per account or per IP, and whether they are enforced at the gateway only — in which case an internal path may bypass them. Separately, look for endpoints where one request causes disproportionate work: an unbounded page size, a nested query in a GraphQL-style interface, or a report generation with no queue.
Injection, still
Less common in framework-managed data access, and still present in the places the framework does not cover: raw queries built for a reporting feature, search and filter parameters, ORM operators accepted from the request, template rendering, and anything passed to a shell or a file path. Test the older endpoints first — they predate the framework conventions the newer ones follow.
Secrets, integrations and logging
Extract keys from mobile binaries and front-end bundles and establish what they actually authorise — a client key with server-side scope is a full compromise. Check third-party integration paths for the same authorisation weaknesses, since they are often exempted from the gateway. Finally, verify that authorisation failures are logged at all: an attack that leaves no trace is an incident-response finding as much as a security one.
The deliverable
What to require of the report
A finding is usable when an engineer can reproduce it from the report without contacting the tester. That means the exact request — method, path, headers that matter, body — the account and role it was sent as, the response that demonstrates the problem, and the response the same request produces from an account that should have access. Screenshots of a proxy tool are not reproduction steps.
Two things separate a good API report from an adequate one. First, pattern identification: if the same authorisation gap appears on four endpoints, the report should say the pattern is likely to exist wherever that handler shape is used, and name the shape. Fixing four endpoints and leaving the other twenty is the most common outcome of a report that lists instances without generalising. Second, exploitability in context: a finding rated on a generic scale without reference to what the affected object actually contains produces a remediation queue nobody can prioritise.
Require the endpoint inventory as an appendix, including the endpoints found that were not in the specification. It is frequently the most valuable artefact in the engagement and the one most often omitted, because it is the input to every subsequent test and to the gateway policy that should have been there.
Common questions
What buyers ask
Can any of this be automated?+
The replay and diff mechanics can and should be — running a few hundred endpoints against several roles by hand is where testers lose days and make mistakes. What cannot be automated is knowing the intended permission for each combination, which is the input the automation needs, and recognising that an anomalous response is a business problem rather than a quirk. Tools that claim to find BOLA automatically are inferring intent from patterns, which produces both false positives and, more dangerously, silence where the pattern is unusual.
How many endpoints can be tested properly in a day?+
It depends far more on the role count than the endpoint count, because the work is a matrix. A hundred endpoints against two roles is a smaller job than forty endpoints against six. As a planning heuristic, expect the authorisation matrix to consume roughly half the engagement, business logic a quarter, and everything else plus reporting the remainder. If a supplier quotes a day count that does not move when you tell them the role count, they have not scoped the authorisation work.
Should the test run against production or staging?+
Staging, where it is a genuine mirror — same authorisation configuration, same gateway rules, same integration paths, representative data volumes. The common failure is a staging environment with relaxed authentication or stubbed integrations, which produces both false findings and false confidence. Where staging does not mirror production, either fix that first or run against production with a defined change freeze, an agreed stop condition and read-only scope on the destructive endpoints.
In this cluster
Discuss an API assessment
A conversation about the API estate you are responsible for — how many endpoints, how many roles, what the inventory position is — and what an assessment would need to cover.
Start the conversation