Skip to content
Tutorials Center
My learning

Topics

Lesson 21 of 38 ยท Scanner and Extensions

Scan Configurations and Insertion Points

Learn how Burp scan configurations control crawl limits, audit coverage and speed, what insertion points are, and how to tune scans for fragile or large applications.

A default scan is a reasonable starting point, but real applications are not default. One is a tiny blog, another is a single-page app with 10,000 routes, a third runs on a server that falls over at 20 requests a second. Scan configurations let you tell Burp how hard and how wide to look. This lesson explains the settings that matter and the idea of the insertion point, which decides where a test payload goes.

The Burp screens below are labelled example output; the Python blocks are stand-ins for the concepts. Nothing here needs a live target.

Built-in and custom configurations

In the scan wizard you choose one or more configurations. Burp ships presets such as:

  • Lightweight: quick audit, fewer checks, good for a first look.
  • Balanced (default crawl and audit).
  • Deep: more crawl depth and more thorough audit, much slower.
  • Minimize false positives / false negatives: trades certainty against coverage.
  • Fast / Thorough crawl, Audit checks - light active, Audit checks - passive, and so on.

You can combine them: later configurations override earlier ones for the settings they define. A custom configuration is a small JSON file you can save, share with the team, and keep with the engagement paperwork so a re-test uses the same settings.

TEXT
Example: custom configuration "Fragile-prod.json" (labelled example)
{
  "crawler": { "crawl_limits": { "maximum_crawl_time": 30, "maximum_unique_locations": 500 } },
  "audit":   { "issues_reported": "passive_only" },
  "scanner": { "requests_per_second": 2, "concurrent_requests": 1 }
}

Crawl settings

Setting What it controls When to change it
Crawl optimization Fast vs thorough link following Use thorough on a small app, fast on a large one
Maximum link depth How many clicks from the start page Lower it on sites with endless "next page" chains
Maximum unique locations Cap on discovered URLs Always set a cap on big sites
Maximum crawl time Wall-clock limit Keeps a scan inside a test window
Login handling Whether the crawler may submit login forms Supply credentials, but not the admin account
Error handling Stop after N failures Prevents hammering a broken server

Audit settings

Setting What it controls
Audit optimization Speed vs coverage; trades fewer checks for more speed
Issues reported Which confidence levels reach you (certain only, or tentative too)
Handling application errors How Burp reacts to 500s during testing
Insertion point types Which parts of a request get test payloads
Frequently occurring insertion points Skip near-identical ones such as a tracking cookie on every request

Request throttling

Under Resource pool (Dashboard, task, Resource pool) you set the maximum concurrent requests and a delay between them. Defaults are fine on a lab; on a customer's staging server start at one request at a time and raise it only if the server stays healthy. A short test: run a throttled scan for a minute and watch response times in the Logger. If latency doubles, slow down.

Agree the request rate in writing before the engagement. "No more than 5 requests per second, weekdays 22:00 to 06:00" is a normal clause, and it protects you as much as the customer.

Insertion points

An insertion point is a location in a request where Burp can place a payload. The scanner does not only try URL parameters. It enumerates many places:

  • URL query parameters and body parameters (application/x-www-form-urlencoded)
  • Cookies
  • Selected headers (Referer, User-Agent, X-Forwarded-For)
  • JSON and XML values, including nested ones
  • Multipart form fields and uploaded file names
  • Path segments (/users/**42**/orders)
  • Serialized or encoded values, such as Base64 blobs that decode to parameters

For every insertion point, every enabled check runs. This is why requests multiply so fast: 12 insertion points times 150 checks times several payload variants is thousands of requests for one page.

Enumerating insertion points yourself

This stand-in walks a request and lists the insertion points a scanner would consider. It is a teaching model, not Burp's code.

Python List insertion points (stand-in)

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

Seeing 13 or so points for one ordinary request explains the request count. It also explains why you should skip insertion points that cannot matter: a theme cookie, an analytics ID. In Burp you can limit insertion point types in the audit configuration or exclude named parameters.

Where a human still wins

The scanner cannot know business rules. It will not notice that changing price=100 to price=1 in a hidden field gives a discount, or that user A can open user B's invoice. Those logic and access-control issues come from manual testing, which later lessons cover (access control).

Practical tuning recipes

  1. First look at a new app: Lightweight audit, passive only, then read the issues. Zero risk.
  2. Single feature: right-click one request and run Audit selected items with Balanced. This is faster than crawling the world.
  3. Authenticated areas: give the crawler a low-privilege test account, and add the logout URL to the exclude list.
  4. Huge site: cap unique locations, scan section by section.
  5. Re-test after fixes: re-run the same saved configuration so results are comparable.

Check your understanding

Quick check ยท 5 questions

of 5 answered You scored / 5 ยท perfect!

  1. 1. What is an insertion point?

    Insertion points are parameters, cookies, headers, JSON values and similar locations where payloads can be placed.
  2. 2. Which setting protects a fragile server during a scan?

    Throttling through the resource pool limits load, which is the main protection for a fragile system.
  3. 3. Why does one page produce thousands of scanner requests?

    Insertion points times checks times payload variants multiplies quickly.
  4. 4. Which kind of problem is a scanner least likely to find?

    Business rules are not visible to generic checks, so human testing is needed.
  5. 5. Why save custom scan configurations?

    A saved configuration documents and repeats your settings.

Summary

  • Configurations set crawl limits, audit coverage, and which issues are reported; presets can be combined and custom ones saved.
  • Throttle with the resource pool and agree the request rate with the system owner.
  • Insertion points cover query, body, cookies, headers, JSON, path segments and more; exclude ones that cannot matter.
  • Scanners miss business-logic flaws, so combine them with manual work.
  • Use light, targeted scans first and save the settings you used.

Next: Triaging scanner findings