- Market
- Saudi Arabia
- Written for
- CISO, CTO
- Decision
- Find out what APIs the organisation exposes and bring them under watch
- Languages
- EN · AR
Enterprise delivery credentials
NCA registration
Registered cybersecurity service provider

ISO/IEC 27001
ISO/IEC 27001 certified
The attacker's afternoon
The road from an unwatched endpoint to a quiet data leak
Nothing on this path requires sophistication; every step uses the API exactly as built, only harder and in an order nobody expected. That is why so many API incidents produce no alert at all.
A flow of four attacker stages — find, probe the authentication, enumerate, extract and monetise — with a branch showing how a monitored, rate-limited edge interrupts each stage.
- 01
Find
Subdomain sweeps, mobile app traffic, JavaScript source and public documentation reveal what the estate answers. The attacker's inventory is often better than the defender's, because building it is their first task and nobody assigned it as yours.
- 02
Probe the authentication
Each endpoint is asked what it gives away without credentials, whether tokens from one context work in another, and whether changing an ID in the request returns someone else's record — the missing object-level check that drives most real API breaches.
- 03
Enumerate
Whatever leaks for one record is requested for every record: sequential IDs walked from one to a million, a search endpoint paged to the end. Without rate limits this is an evening's scripting, indistinguishable in each single request from a legitimate call.
- 04
Extract and monetise
The harvested data — profiles, phone numbers, order histories, credentials — is sold, used for fraud and phishing, or held over the organisation. The victim usually learns of the leak from the outside, because nothing on their side was watching.
The watched edge
Every stage of this path has a signature — discovery sweeps, authentication probing, request rates no human produces. An edge with rate limits and monitoring turns each stage into an alert and a block; an unwatched one turns them into a quiet success.
The first control
An API inventory is the security control that comes before all the others
Authentication, rate limiting and monitoring all share a dependency: they apply only to endpoints somebody knows about. And estates accumulate endpoints nobody knows about faster than they think. The v1 API kept alive after v2 shipped, because two integrations never migrated. The staging service exposed for a demo and never withdrawn. The endpoint a developer added for a mobile feature that was cancelled, still deployed. The microservice that was internal until a load balancer change made it not. These zombie and shadow endpoints run old code, miss the patches and controls the documented API received, and appear on no dashboard — which is precisely what makes them the attacker's preferred entrance.
A real inventory is therefore built from both directions and reconciled. From the outside: what does the internet actually get an answer from, across every subdomain, port and path discovery can reach. From the inside: what do the gateways, load balancers, DNS records, cloud configuration and codebases say should exist. The differences between the two lists are the findings — endpoints answering that no configuration explains, and endpoints configuration promises that answer differently than documented. From then on the inventory has to be maintained the way the code is: a deployment that changes the edge updates the inventory, or the estate begins forgetting again the day the exercise ends.
The giveaways
Four ways an exposed API hands out more than anyone intended
Each of these passes a functional test, which is why testing for function is not testing for exposure.
- 01
The response built for a screen that shrank
The endpoint returns the full user object because the first client needed most of it; today's client shows three fields and discards the rest — but the rest still crosses the wire, and an attacker reads the response, not the screen. Over-broad responses turn one small leak into a rich one.
- 02
The check that stops at the front door
The API verifies that the caller is signed in but not that the record requested belongs to them — so any customer with a valid token can read any customer by changing an ID. This single missing check accounts for more real-world API breaches than any exotic technique.
- 03
The endpoint with no concept of too fast
No rate limit means a login endpoint will patiently check a million passwords and a lookup endpoint will serve the whole database one record at a time. Limits, and abuse handling for what exceeds them, are what make an attacker's scale expensive.
- 04
The error that explains too much
Stack traces, framework versions, internal hostnames and which of username or password was wrong — debugging conveniences that map the estate for whoever asks badly on purpose. Production errors should say enough for the caller and nothing for the cartographer.
Our role
What we map at your edge and what your engineers then own
- 01
The reconciled inventory
We discover from the internet inward and from your configuration outward, and hand over the reconciliation: every endpoint that answers, who owns it, what it demands of a caller, and which ones nothing on the inside explains.
- 02
The authentication surface, reviewed
Each exposed endpoint is checked for what it serves unauthenticated, whether its authorisation reaches the object level, and where tokens outlive their purpose — with findings ordered by the data behind the door rather than by count.
- 03
A monitored edge, handed over
Rate limits, abuse handling and edge monitoring are designed against your real traffic and left running in your tooling, with your team reading the dashboards — because an edge only a consultant watches goes dark at the end of the engagement.
Which endpoints stay public, and how much friction each integration bears, are product decisions that stay yours; deeper exploitation testing of the endpoints that matter is its own engagement, scoped once the inventory shows where it is worth aiming.
Common questions
What buyers ask
How do APIs end up exposed without anyone noticing?+
Through ordinary delivery, not negligence. A mobile release ships with new endpoints and the old ones stay up for users who have not updated. A partner integration goes live on a subdomain and the partnership ends before the endpoint does. A migration to microservices multiplies the number of things that answer HTTP, and one load balancer rule quietly makes an internal service reachable. Each event is small and justified at the time; nobody's job is to notice their accumulation. The estate's documentation describes the API as designed, the edge serves the API as deployed, and the gap between the two grows a little with every release — which is why discovery has to interrogate the edge itself rather than trust any list.
Our APIs are only called by our own apps — are they still at risk?+
Yes, because "only our apps call it" is a description of your intention, not of what the endpoint enforces. An API that serves your mobile app is on the public internet, and anyone can open the app's traffic with an intercepting proxy, read every call it makes, and then make those calls themselves — modified, re-ordered, at a scale no app would produce. Embedded API keys can be pulled from the published binary; the server cannot verify which client is talking to it, only which credentials arrive. The design consequence is that the API must defend itself as if the app did not exist: authenticate every request, authorise at the object level, limit rates and validate input on the server. The app is a convenience for your users; it is not a security boundary.
What is a zombie API, and why is it a problem?+
A zombie API is an endpoint that outlived its purpose but not its deployment: the v1 kept running after v2 shipped, the feature that was cancelled after its API went live, the demo service nobody withdrew. It is a problem for three compounding reasons. It runs old code, so vulnerabilities patched in the current API are still alive in it. It is absent from documentation and dashboards, so no monitoring covers it and no review includes it. And it often retains the access of its era — the same database, the same internal network — so compromising it pays as well as compromising the maintained API, at a fraction of the difficulty. The fix is procedural as much as technical: discovery to find the ones already out there, and a decommissioning step in delivery so that retiring an API means actually switching it off.
In this cluster
Map your API edge with us
An edge-mapping exercise that reconciles what your documentation claims against what the internet can actually reach, with the unauthenticated and unwatched endpoints named first.
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
