API & GraphQL Security Testing
Testing of REST and GraphQL APIs on their own terms, without the web or mobile client in the way. Most API findings are authorisation failures rather than injection, and they are invisible to anything that only drives the user interface.
Object and function level authorisation, broken authentication, resource consumption limits, GraphQL introspection and query depth, mass assignment, and the deprecated endpoints still answering requests after the client stopped calling them.
What we cover
Object level authorisation
Whether changing an identifier in a request returns somebody else's data. The most common serious API finding, and the hardest for a scanner to recognise.
Function level authorisation
Endpoints that check you are logged in but never check whether you are allowed, including admin routes reachable by ordinary accounts.
Property level authorisation
Responses that return more fields than the client displays, and requests that accept more fields than the client sends.
Resource consumption
Missing rate limits, unbounded pagination, and GraphQL query depth or batching that lets one request do unreasonable work.
GraphQL specifics
Introspection exposure, schema disclosure, alias and batching abuse, and resolvers that enforce authorisation inconsistently across the graph.
Inventory and drift
Undocumented endpoints, superseded API versions still live, and staging routes reachable from production.
An API is not tested by testing the thing that calls it. A web front end or a mobile app only ever sends the requests its developers thought to implement, in the order the interface allows. An attacker sends whatever the endpoint will accept.
That gap is where most serious API findings live, and it is why an API needs testing as a system in its own right rather than as a by-product of testing a client.
Authorisation is the whole game
Seven of the ten entries in the OWASP API Security Top 10 are some form of access control failure, and the top three all are. This matches what we find in practice: the expensive API bug is almost never a malformed input reaching a database. It is a well-formed, authenticated request for a record belonging to somebody else.
Nothing about that request looks wrong. It has a valid token, valid syntax and a plausible identifier. A scanner has no way to know that the identifier should have been refused, which is why this class of finding survives automated testing and reaches production.
How we test
We start from whatever documentation exists, then stop trusting it. Specifications drift, and the endpoints that are missing from the documentation are disproportionately the interesting ones. We enumerate what the API actually exposes, build a picture of its object and permission model, and then test that model from the position of each role, including unauthenticated.
For GraphQL the shape of the work changes. A single endpoint with a self-describing schema removes the discovery problem and replaces it with a different one: authorisation has to hold consistently across every resolver and every path through the graph, and it frequently does not. We test for inconsistent enforcement between a direct query and the same data reached through a nested relationship.
Where this sits alongside our other work
If your API exists to serve a mobile application, this work overlaps with our mobile auditing and the two are usually scoped together. If the API is part of a Laravel or Symfony application we already have source access to, the code audit and the API test inform each other: we can confirm from the code why an endpoint behaves the way it does rather than inferring it from responses.
The tools an AI agent calls are almost always an HTTP API, and an agent is a client that will send whatever it is persuaded to send. If your API sits behind an agent, our AI and LLM application security work covers the permission model around it and the two are usually scoped together.
What you get
01
A written report mapped to the OWASP API Security Top 10 (2023) with severity per finding
02
A reproducible request sequence for every exploitable issue
03
Remediation guidance at the route and middleware level, not just the symptom
04
A follow-up review of your fixes once remediation is complete
Other services
Every engagement starts with a conversation about scope. Tell us what you have built and what worries you about it, and we will tell you what a useful assessment looks like.