Cybersecurity credentials
NCA registration
Registered cybersecurity service provider

ISO/IEC 27001
ISO/IEC 27001 certified
The attack surface
Every client hitting the same authorisation decision
A web front end, a mobile app and a partner integration all reach the API the same way — as requests. The drawing exists to show that the interface a user sees is one client among many, and the only thing standing between any of them and your data is the authorisation check on each call.
Three clients — a web front end, a mobile app and an attacker's own script — all converging on a single authorisation check, which must decide object-level and function-level access on every request.
The web front end
The client you designed, sending the requests you expected in the order you expected.
The mobile app
The same API, called from a device where the request can be intercepted and altered before it is sent.
An attacker's own client
A script that ignores your UI entirely and sends whatever request it likes — a different object id, a method the front end never calls, a missing field.
What we do
The authorisation check on each request
The only reliable boundary. It must re-decide, on every call, whether this identity may perform this action on this specific object — not trust that the client would only ask for what it should.
Object-level authorisation (BOLA/IDOR)
Can a request change one identifier and read another customer's record? The most common and most damaging API flaw, and invisible to a scanner that does not know whose data is whose.
Function-level authorisation
Can an ordinary user call an endpoint meant for an administrator simply by knowing its address? The check the front end enforced by hiding the button, but the API forgot to enforce itself.
Almost every serious API finding is a request that asked for something and was not told no.
The flaw in plain terms
What broken object-level authorisation looks like without the acronym
Strip away the terminology and the most damaging API flaw is simple. A request to view an invoice carries the invoice's number. The application shows you the invoice. Change the number in the request to one you were never given, and if the code fetches the record without first checking that it belongs to you, it hands you a stranger's invoice. That is broken object-level authorisation — often written BOLA or IDOR — and it is common because the front end only ever sends numbers you are entitled to, so the missing check is never exercised until someone stops using the front end.
The related flaw is function-level: the front end hides the delete-user button from ordinary staff, so the team assumes the action is protected. But hiding a button only removes it from the screen; the endpoint it called is still there, and if the API does not itself check the caller's role, anyone who learns the address can call it. Testing an API means sending exactly the requests the front end would never send — a foreign identifier, an administrative endpoint from an ordinary account, a field the client always omitted — and confirming the API says no every time.
Beyond authorisation
The API abuse cases a functional test never runs
Authorisation is the largest category but not the only one. These are the checks that treat the API as something to be misused rather than merely used, and none of them appears in a specification written to describe correct behaviour.
Rate limiting and enumeration
An endpoint that returns a record by id, with no limit on how fast it can be called, is a way to download every record by counting. We test whether the API resists being called a hundred thousand times as readily as it serves one honest request.
Mass assignment and extra fields
If a request to update your profile also accepts an is-admin field the client never sends, an attacker who adds it may promote themselves. We send the fields the front end omits and watch whether the API quietly accepts them.
Schema drift from the documentation
The specification describes the API someone intended; the code implements the one that runs. Endpoints the docs omit, parameters they no longer mention, deprecated routes still live — the gap between the two is where forgotten exposure sits.
Error responses that say too much
An error that returns a stack trace, an internal path or a database message hands an attacker the map they were building by hand. We check that failures fail closed and quiet rather than helpfully.
Our role
What the API test proves, and where the back-end systems remain your ground
- 01
We test every role against every object
With a test account per role, we confirm that each endpoint re-checks object and function authorisation on the server rather than trusting the client, because that is where the damaging findings are.
- 02
We read the drift, not only the docs
We compare the documented contract against what the running API actually accepts, so an endpoint the specification forgot is tested rather than assumed not to exist.
- 03
Your team owns what sits behind the API
The assessment proves the API enforces its rules; the security of the databases and services it calls behind it is a separate question your team owns, and we say plainly where our scope ends.
Which findings to remediate first, and how to change the authorisation model behind them, are your team's decisions; we prove which requests the API wrongly permits, show the exact call that demonstrates each, and hand back a fix an engineer can apply.
Common questions
What buyers ask
Why test an API separately when we already test the web application it powers?+
Because a web test drives the API only the way the front end does, and the front end is the one client that behaves. It sends the requests you designed, in the order you expected, asking only for objects the user is entitled to. An attacker ignores the front end entirely and calls the API directly with any request they like — a foreign object identifier, an administrative endpoint, an extra field the client never sends. The most damaging API flaws are exactly the ones the front end never triggers, so a test conducted through the UI never reaches them. Testing the API as its own surface means sending the requests your own application would never send.
Does testing a GraphQL API differ from testing a REST one?+
The underlying flaws are the same — object and function-level authorisation dominate both — but the shape of the surface differs and changes how we test. REST spreads its operations across many endpoints and methods, so the work is enumerating them and checking authorisation on each. GraphQL exposes a single endpoint over a rich, introspectable graph, which concentrates the surface but adds its own risks: a query nested deeply enough to exhaust the server, a field reachable through one type that authorisation forgot to guard when reached through another, and introspection that hands an attacker the whole schema unless it is disabled. We adapt the abuse cases to the style, but the question — does the server re-check authorisation on every field and every object — is identical.
We have an OpenAPI specification. Is that enough to scope the assessment?+
It is a strong start and never the whole picture. The specification is a great scoping input — it tells us the endpoints, the parameters and the roles as they were intended — but part of the assessment is precisely finding where the running API has drifted from it: routes the docs omit, parameters they no longer mention, deprecated endpoints still live and unlisted. We use the specification to plan the test and then check reality against it, because the gap between the two is where forgotten exposure sits. We also ask for a test account per role, since object and function-level authorisation cannot be proven without being able to make a request as each kind of user.
In this cluster
Next step
Point us at the API and its docs
A scoped API assessment with the specification and test accounts for each role, returning authorisation, abuse-case and schema-drift findings with the request that demonstrates each and the fix.
Point us at the API and its docs
What happens next
- 1We reply within one business day.
- 2A 30-minute scoping call with a senior consultant.
- 3A written proposal with scope, team, and timeline.
Or reach us directly
