Next-Gen DAST: The API Test Your Shortlist Is Missing
Traditional DAST passes APIs that leak data. Here is what logic-aware, next-gen DAST must test, and the POC checks to put on your DAST shortlist.

Next-generation DAST is dynamic testing that understands the application, not just its inputs. For APIs, that means testing whether a valid request succeeds for the wrong user. Traditional DAST looks for requests that break an application. The most common API flaws, like broken object level authorization (BOLA), are requests that work perfectly for someone who should not be allowed to send them. A next-gen DAST shortlist should test five things: discovery beyond the spec, multi-identity authorization testing, stateful workflow testing, proof of exploit with replayable evidence, and the same answer on every run.
Traditional DAST misses API flaws where a valid request succeeds for the wrong user.
Logic-aware testing needs multiple identities: users, roles and tenants.
Score DAST tools on proven exploits, not on how many findings they produce.
Run three POC tests: seed a BOLA, run three times on one commit, fix and rerun.
Key terms
- DAST (dynamic application security testing): testing a running application from the outside by sending requests and inspecting responses.
- Logic-aware testing: testing that knows who the caller is, what they own, and what they are allowed to do, then checks whether the application enforces it.
- BOLA (broken object level authorization): a user reads or changes an object that belongs to someone else by changing its ID. It is API1 in the OWASP API Security Top 10.
- BFLA (broken function level authorization): a low-privilege user calls a function meant for a higher role, such as an admin route.
- Workflow abuse: skipping, repeating or reordering the steps of a business process, such as checkout, refund or onboarding.
- Application Exploit Validation (AEV): proving which weaknesses an attacker can actually use, against the running application, with evidence you can replay.
Why does traditional DAST pass an API that leaks data?
Because the request that leaks data is a valid request. Classic DAST crawls, sends malformed or malicious input, and watches for errors, crashes and known signatures. That finds injection and misconfiguration. It does not find a request that is well formed, authenticated and returns 200 OK for the wrong person.
Here is a BOLA in two requests. User A owns account 1001. User B owns account 2002.
GET /api/v2/accounts/1001
Authorization: Bearer <token for User A>
HTTP/1.1 200 OK
{"id": 1001, "owner": "user-a", "balance": 4210.55}GET /api/v2/accounts/2002
Authorization: Bearer <token for User A>
HTTP/1.1 200 OK
{"id": 2002, "owner": "user-b", "balance": 18930.10}The second response is the vulnerability. Nothing in it looks wrong to a scanner. There is no error, no stack trace and no payload. You only see the flaw if the test knows that User A should not own account 2002. That takes at least two identities and a model of who owns what.
This is not an edge case. OWASP rates BOLA as easy to exploit and widespread, and calls it "extremely common in API-based applications" (OWASP API1:2023). In an analysis of 11,053 API-related vulnerabilities published in 2025, BOLA was the most common OWASP category at 39%, and 97% of the API vulnerabilities could be exploited with a single request (Wallarm API ThreatStats Report 2026).
For the basics of static and dynamic testing, see the difference between SAST and DAST.
What does logic-aware API testing actually test?
It tests whether the application enforces who can do what, to which object, in which order. That breaks into three classes of test, and a next-gen DAST tool should run all three against the live application.
1. Object-level tests (BOLA). Log in as two users with the same role. Take every request that carries an object ID, and replay User A's request with User B's identity and User A's object. Any success that returns another user's data is a confirmed exploit. Repeat across tenants, not just users.
2. Function-level tests (BFLA). Build the permission matrix: every role against every route and method. Call admin, support and internal functions as a standard user, and as an unauthenticated caller. The test is the whole matrix, not one sample route.
3. Workflow tests. APIs encode business processes: sign-up, checkout, refunds, approvals, password reset. Logic-aware tests skip steps, repeat steps, reorder them, and replay them at volume. In the 2024 Dell incident, an attacker said they registered fake partner accounts, then enumerated seven-digit service tags against an order-lookup API at about 5,000 requests a minute for roughly three weeks, and claimed 49 million records (BleepingComputer). Each request was valid on its own. The abuse was in the pattern.
Attackers are moving this way. Akamai reports that API attacks aimed at unauthorized workflows roughly doubled from 2024 to 2025, and that modern API threats have shifted toward business logic abuse that often has no recognizable signature (Akamai, Apps, APIs, and DDoS 2026).
These three classes map to the layers where real applications fail: business logic, data access, and roles and permissions. Real applications don't break in one place. They fail where the layers meet. More examples: what BOLA is and how to fix it and five business logic failures that led to breaches.
What do security teams see in the field?
The gap is rarely the scanner. It is what the scanner was never pointed at, and who it was logged in as. Three patterns from recent conversations with enterprise security leaders:
- A global financial institution could see roughly a fifth of its repositories and was still loading API specs by hand. It could not yet show a strong story on role-based access control.
- A large insurer was carrying 10,000 code findings, about half in code that never runs. Its dynamic testing stopped at the interface.
- At a recent CISO roundtable, leaders described handing the same application to five testers and getting five different lists.
In each case, more findings would not help. What helps is a short list of what is proven exploitable, on the APIs that actually run. For scale, one apisec test program ran 71,780 validations across 485 endpoints, covering roughly 80 security categories. One confirmed result: GET /api/v2/accounts/{id} returned other tenants' accounts, exposing 2,814 records, verified against the live application.
Why does this matter now?
Finding logic flaws used to take a skilled human and time. Now it takes a model and a budget. Frontier and open-weight models can map an application and probe its authorization at machine speed. In its first update on Project Glasswing, Anthropic reported that AI-driven vulnerability discovery produced more than ten thousand high- and critical-severity findings across roughly fifty organizations in about a month (Anthropic, Project Glasswing: An initial update, May 2026).
The cost lands on defenders. Bank of America told CNBC it added 1,000 external contractors to 3,000 internal staff to fix code exposed by frontier models, at a cost of a couple of hundred million dollars in one quarter (CNBC, October 2026).
Attackers can afford to be probabilistic. They only need one working path, and every attempt keeps getting cheaper. Defenders need every path tested, on every release, with the same answer every run.
What belongs on a next-gen DAST shortlist?
Score every tool on whether it can prove logic flaws in your APIs, not on how many findings it produces. Use this table in vendor calls and proofs of concept.
| Criterion | Why it matters for APIs | Ask the vendor | POC pass |
|---|---|---|---|
| Discovery beyond the spec | Shadow, zombie and undocumented APIs are not in your OpenAPI files or gateway | How do you find APIs we didn't give you? | Finds endpoints missing from the specs you supplied |
| Multi-identity testing | BOLA only shows up when one identity touches another's object | How many users, roles and tenants does one test run hold? | Runs with at least two users per role and two tenants |
| Authorization matrix | BFLA hides in role and route combinations nobody sampled | Do you test every role against every route and method? | Produces a role-by-route result, not a sample |
| Stateful workflow tests | Logic abuse lives in step order, replay and volume | Can you skip, repeat and reorder multi-step flows? | Flags a skipped step in a checkout or approval flow |
| Proof of exploit | Your fixers are the scarce resource | What evidence comes with each result? | Replayable request and response that shows the data exposed |
| Same answer every run | Probabilistic tools return different lists on the same code | Will two runs on the same build match? | Three runs on one commit return the same list |
| Fix confirmation | The board asks when the backlog is closed | How do you show a fix worked? | Rerun flips the result from confirmed to cleared |
| Pipeline fit and cost | Logic changes on every release | What does it cost to run on every build? | Runs in CI at a fixed, predictable cost |
| AI and MCP surface | Agents and MCP servers call your APIs too | Do you discover and test AI and MCP call sites? | Lists LLM providers and MCP servers in the code |
Which proof-of-concept tests should you run?
Run these three on one application before you sign.
- Seed a known BOLA. Pick an endpoint you know lets one user read another's object, or build one in a test environment. Give each tool two users. A tool that misses it is not logic-aware.
- Run it three times on the same commit. Compare the three outputs. If the code did not change and the lists did, the difference is noise, and noise is where human hours get wasted.
- Fix and rerun. Patch the seeded flaw and run the same scenario. The result should flip from confirmed to cleared, with evidence.
What this means for your program
- Add authorization and logic to your DAST requirements. Make multi-identity BOLA, BFLA and workflow testing pass-or-fail criteria, not nice-to-haves.
- Start with an inventory. You can't test what you don't know exists. Ask for discovery across code, gateway and runtime, not just the specs you hand over.
- Give every test more than one identity. Set up at least two users per role and two tenants in your test environment before the POC starts.
- Rank by proof. Ask for results that are confirmed against the running application, ordered by the data they expose.
- Hold vendors to repeatability. Same commit, same answer. Make the three-run test part of every evaluation.
Where apisec fits
Keep your SAST, DAST and SCA. They find. apisec proves. apisec is Application Exploit Validation: it shows which weaknesses an attacker can actually use, and confirms when they're fixed.
- apisec Surface discovers every application and API across code, web, gateway and runtime, including the ones missing from your catalog.
- apisec App Model builds a living model of each application: routes, identities, authentication, authorization, data flows, agents and MCP servers.
- apisec Exploit Testing decides which tests to run where, runs them against the live application with multiple identities, and records each result as confirmed, cleared or blocked, with replayable evidence.
See every way in. Prove what an attacker can use. Confirm the fix.
Next step: start free with apisec and run your first validation on one application, or map your estate with the free apisec Surface tools.
FAQ
Is traditional DAST enough for API testing?
No. Traditional DAST finds injection, misconfiguration and known signatures. The most common API flaws, like broken object level authorization, are valid requests that succeed for the wrong user. Finding them takes multiple identities, a model of who owns what, and tests that check authorization and workflow logic against the running application.
What is logic-aware API testing?
Logic-aware API testing checks whether an application enforces its own rules: who can read which object, which roles can call which functions, and which steps must happen in which order. It runs as several users, roles and tenants at once, and treats a successful request by the wrong identity as a confirmed exploit.
How do I test a DAST tool for BOLA in a proof of concept?
Set up two users with the same role. Seed an endpoint where one user can read the other's object by changing an ID. Give the tool both identities and see whether it reports the exposure with a replayable request and response. Then fix the flaw and confirm the result flips to cleared.
How is Application Exploit Validation different from DAST?
DAST reports potential vulnerabilities in a running application. Application Exploit Validation proves which weaknesses an attacker can actually use, with evidence, then confirms the fix. apisec's view is that it complements DAST: DAST finds, and exploit validation tells your team which findings are real and which to fix first.
Sources
- OWASP API Security Top 10, API1:2023 Broken Object Level Authorization
- Wallarm, API ThreatStats Report 2026, 17 Feb 2026
- Akamai, Apps, APIs, and DDoS 2026
- BleepingComputer, Dell API abused to steal 49 million customer records, 10 May 2024
- Anthropic, Project Glasswing: An initial update, 22 May 2026
- CNBC, 14 Oct 2026
The deploy gate is the last control point
The depth of a human. The coverage of a machine.
Start free and see a proven exploit against your own application, or get a walkthrough tailored to your stack.