In 2025, the Marks & Spencer breach exposed customer PII through an unauthenticated API endpoint that a basic active scan would have flagged in minutes. The testers who missed it were working manually, skipping Burp Suite Pro’s automated crawl-and-audit pipeline entirely. That’s the gap this post closes.
Active Scanning a Specific Endpoint
Burp Suite Pro’s active scanner doesn’t just spider — it probes every parameter with payloads tailored to the detected technology stack. Most testers run it against an entire host and drown in noise. The sharper move: scope it to a single high-value endpoint you’ve already identified manually.
Right-click any request in Proxy > HTTP History and choose Do active scan. Or send it to Scanner via the API. Here’s how to trigger a targeted scan from the command line using Burp’s REST API (enabled under User options > REST API):
curl -s -X POST http://127.0.0.1:1337/v0.1/scan \
-H "Authorization: Bearer burp_api_key_7x9mQpL" \
-H "Content-Type: application/json" \
-d '{
"urls": ["https://app.targetcorp.internal/api/v2/users/profile"],
"scope": {
"include": [{"rule": "https://app.targetcorp.internal/api/v2/"}]
},
"scan_configurations": [{"name": "Audit checks - critical issues only"}]
}'
# Response
{"task_id": "4e81a2f9-c3b7-4d20-ae77-012f8b6c1d3a"}
That task_id is your handle to poll scan progress. Hit GET /v0.1/scan/4e81a2f9-c3b7-4d20-ae77-012f8b6c1d3a and watch scan_status move from running to succeeded. When it completes, the issues array in the response will list findings with severity, confidence, and the exact request that triggered them — no GUI required. This matters in CI/CD pipelines where you need machine-readable results.
What does a hit look like? If the scanner finds a reflected XSS on the filter parameter, the response includes the injected payload, the evidence string captured from the response, and a remediation reference. That’s your starting point for a manual proof-of-concept, not a finished finding — always reproduce it by hand before reporting.
Intruder: Credential Stuffing Simulation and Account Enumeration
Burp Intruder is a precision fuzzer. Forget the brute-force reputation — its real power is testing business logic: account enumeration, rate-limit bypass, and parameter tampering at scale.
Here’s a real scenario. You notice POST /api/v2/auth/login returns different response times for valid versus invalid usernames — a classic timing oracle. Capture the request in Proxy, send it to Intruder, and set up a Sniper attack on the username field:
POST /api/v2/auth/login HTTP/1.1
Host: app.targetcorp.internal
Content-Type: application/json
X-Forwarded-For: 192.0.2.47
{"username": §admin§, "password": "Winter2026!"}
# Intruder results (truncated)
Payload Status Length Time (ms)
--------------------------------------------
admin 200 312 847
j.morrison 200 312 851
svc_deploy 200 312 839
fakeuser999 200 289 112
guest_acct 200 289 108
test 200 289 115
The timing split is obvious. Responses for admin, j.morrison, and svc_deploy take ~850ms — the backend is hitting a database lookup and running a password hash comparison. Invalid users bail out in ~110ms. You’ve enumerated three valid accounts without a single failed login alerting on a lockout policy.
What do you do next? Export the valid usernames, pivot to the password spray phase with a single common password per account (staying under lockout thresholds), and document the timing delta as an enumeration vulnerability — OWASP OAT-004. Report it as medium severity: low effort for an attacker, concrete fix for the dev team (constant-time response regardless of username validity).
Bambda Filters: Cutting Through Proxy Noise
Burp 2024+ replaced the old display filter syntax with Bambdas — small Java lambda expressions that run against every item in HTTP History. This is where advanced users separate themselves from people still clicking checkboxes.
You want to find every response that sets a cookie without the HttpOnly flag and also returns JSON — the overlap that signals an API leaking session tokens to JavaScript:
// Bambda filter — paste into HTTP History filter bar
return requestResponse.response() != null
&& requestResponse.response().headers().stream()
.anyMatch(h -> h.name().equalsIgnoreCase("Set-Cookie")
&& !h.value().toLowerCase().contains("httponly"))
&& requestResponse.response().headers().stream()
.anyMatch(h -> h.name().equalsIgnoreCase("Content-Type")
&& h.value().contains("application/json"));
Hit Enter. Your 4,000-request history collapses to exactly the items that match. Every result is a candidate for a session-hijacking finding. Click each one, check the cookie name, verify it’s a session or auth token, and you’ve got a reportable misconfiguration tied to a specific endpoint — not a theoretical risk.
What To Do Now
Open Burp Suite Pro, enable the REST API under User options > REST API, and trigger a targeted active scan against one endpoint from an application you’re currently testing — not the whole host, one endpoint. Pull the results via curl, paste the JSON into your notes, and reproduce the top finding manually before you close the laptop. That single habit — API-driven, scoped, manually verified — is what separates a credible pentest report from an automated scanner dump.
