- 01
Market
Saudi Arabia
- 02
Written for
CTO, CISO
- 03
Decision
Commission a penetration test of an API estate
- 04
Languages
EN · AR
Cybersecurity credentials
NCA registration
Registered cybersecurity service provider

ISO/IEC 27001
ISO/IEC 27001 certified
Scoping
Count the consumers, not the endpoints
We do not have an office in Saudi Arabia
We serve organisations there from our Riyadh office and our engineering hubs in Lahore and Karachi, travelling for the parts of an engagement that need to happen in person.
An endpoint count tells you almost nothing about the work. Two hundred endpoints called by one first-party mobile client with one permission model is a narrow test. Forty endpoints called by a web client, a mobile client, three partner integrations and an internal batch process is a wide one, because each caller has a different token type, a different scope and a different set of assumptions about what it is allowed to do.
The specification is the second input, and its absence changes the engagement. With an OpenAPI or GraphQL schema we test what the API claims to offer against what it actually accepts, and the gap between the two is itself a finding — undocumented parameters that still work, deprecated versions still routed, admin operations present in the schema and absent from the documentation. Without a specification the first days go to reconstructing one, and the test is only as complete as that reconstruction.
Third: whether the gateway is in scope. Rate limiting, authentication and schema validation are frequently implemented at a gateway rather than in the service, which means testing the service directly measures something the internet cannot reach, and testing through the gateway measures the gateway. Where both paths exist — and they usually do, because internal callers bypass the gateway — both need testing, and the difference between them is often the finding.
Coverage
Where API tests actually find things
Object-level authorisation
The identifier in the path or body swapped for one belonging to another account in the same role. The single most productive check in this category, and the one an automated tool cannot perform because it does not know which two identifiers should not be interchangeable.
Function-level authorisation
Administrative operations called with an ordinary token. Where the client hides a button, the API frequently still honours the call — the interface enforced the rule and the service assumed the interface would.
Token handling
Whether a token is validated for signature, audience, issuer and expiry rather than merely decoded; whether refresh tokens can be replayed; whether revocation takes effect before the cached copy expires; and what a token issued for one client accepts when presented to another.
Mass assignment and over-posting
Fields the client never sends, accepted anyway. A role field, an account balance, a verified flag, an owner identifier — present in the model, absent from the interface, and writable by anyone who reads the response carefully.
Enumeration and bulk access
Sequential identifiers, unbounded page sizes, search filters that accept a wildcard, and export endpoints with no rate limit. Individually each returns one record it should not; together they return the dataset.
GraphQL-specific behaviour
Introspection left enabled in production, query depth and complexity unbounded, aliasing used to bypass a per-field rate limit, and mutations reachable that the schema documentation does not describe.
Sequence
How the engagement runs
1 · Specification and caller map
The schema, the consumers, the token types each holds, and the objects each is meant to reach. Where the map does not exist we build it and return it, which is frequently the first thing the client keeps. A caller-to-object matrix the test is measured against.
2 · Authorisation matrix execution
Every operation attempted with every token type, and every object identifier substituted across accounts. This is the bulk of the days and the source of most findings. A filled matrix: permitted, denied, or permitted and should not be.
3 · Input, state and rate behaviour
Schema validation bypasses, type confusion, state transitions called out of order, and what happens when the same operation is called a thousand times in a minute. Findings against handling rather than against permission.
4 · Report and retest
Each finding as the exact call, the token it was sent with and the response. Retest checks the fix and whether it was applied to every operation sharing the pattern. A document an engineer can act on without a call.
Scope boundary
What an API test covers
What we do
- Test both the gateway path and the direct service path where both are reachable, and report the difference between them.
- Record the exact call, token and response for every finding, so a fix can be verified the same way it was found.
- State which operations in the specification were not reached, and why.
Where an API is in scope for a financial services framework, the supervising authority sets what evidence it accepts and from whom. Confirm the required scope, tester independence and report format with the assessor before the engagement is scoped.
Primary sourceCommon questions
What buyers ask
We have an OpenAPI spec. Is that enough to scope the work?+
It is most of it, but not all. The specification describes the operations; what it rarely describes is which callers exist, which token type each holds, and which objects each is meant to reach. That last part is the authorisation matrix, and it is where the findings are. If it has not been written down, the first day of the engagement produces it — and clients usually find that document more useful than they expected.
Can you test an API that is only reachable from inside our network?+
Yes, over a controlled connection you provision — a jump host, a VPN account, or a workstation on your estate that we work from. Internal APIs are frequently worth testing precisely because they were built on the assumption that only trusted callers reach them, and that assumption holds only until one workstation is compromised.
How does this differ from the web application test?+
A web application test exercises the API through the interface, which means it only reaches the calls the interface makes, in the order the interface makes them. An API test calls the service directly, which reaches undocumented operations, parameters the client never sends and sequences the interface prevents. Where the same team owns both, testing them together is cheaper than testing them separately — but a web test alone does not cover the API.
In this cluster
Next step
Send the spec and the caller list
A scoped API test with two accounts per role and the specification in hand. Findings written as the exact call that succeeded and should not have.
Send the spec and the caller list
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
