Techbanq

Cybersecurity · API exposure

The internet is already calling APIs you forgot you published

Every mobile app, partner integration and microservice migration leaves endpoints behind on the public internet, and the ones nobody documents are the ones nobody watches. We map what your estate actually answers, review how each endpoint decides who may ask, and put the edge under monitoring — so the next probe meets a defence instead of a forgotten door.

Serving Saudi Arabia from our Riyadh office and our engineering hubs in Lahore and Karachi

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

  • National Cybersecurity Authority, Saudi Arabia

    NCA registration

    Registered cybersecurity service provider

  • ISO

    ISO/IEC 27001

    ISO/IEC 27001 certified

Certifications & registrations

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.

  1. 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.

  2. 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.

  3. 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.

  4. 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.

Always available

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.

  1. 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.

  2. 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.

  3. 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.

  4. 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

  1. 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.

  2. 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.

  3. 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.

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

  1. 1We reply within one business day.
  2. 2A 30-minute scoping call with a senior consultant.
  3. 3A written proposal with scope, team, and timeline.

Or reach us directly

By submitting this form you agree to our Terms of Use and Privacy Policy.