In Burp Suite's Sequencer, how do live capture and manual load differ, and what token sample sizes does the documentation give?
answer
- one request, issued repeatedly
- tokens you already hold
- three sizes worth knowing
- FIPS explains the ceiling
- who sees the repeated requests
basics
~20 sLive capture reissues one request and extracts the token from each response; manual load takes tokens you already hold, newline-delimited. In Burp Suite 2026.9, analysis needs 100 tokens, about 5,000 is usually sufficient, and 20,000 is the maximum.
solid answer
~40 sIn Burp Suite 2026.9, Sequencer gets a sample two ways. **Live capture** repeatedly issues a chosen request and extracts a token from each response, from a cookie, a form field or a custom location. **Manual load** takes tokens you already have, pasted or loaded as simple newline-delimited text. Analysis needs at least 100 tokens, but the page says 100 should not be considered reliable for any serious purpose; 5,000 is usually sufficient, depending on the sample; and 20,000 is the maximum, for compliance with the FIPS standards. To the application owner a live capture is a burst of near-identical requests that each mint a session, so the page advises non-production systems until you know the tool, and the number of threads and the throttle between requests are settings you can bound.
go deeper
Say Sequencer measures how random a set of tokens looks, and that you give it tokens either by live capture or by loading a list.
Quote the sample sizes from the page: 100 is the floor and unreliable, 5,000 is usually sufficient and 20,000 is the maximum; name the three token locations.
Describe a live capture as the owner sees it, a burst of near-identical requests creating sessions, and plan it: written scope, non-production first, bounded threads and throttle.
Decide where capture happens in the assessment standard: the environment it may run in, who approves the load, and who is told when session creation spikes.
## What Sequencer takes Burp Suite's **Sequencer** analyses the quality of randomness in a sample of tokens that are meant to be unpredictable: session tokens, anti-CSRF tokens and password reset tokens are the examples the documentation gives. Before any analysis there has to be a sample, and there are two ways to get one. This answer follows the documentation of Burp Suite Professional and Community 2026.9. ## Live capture You find a request whose response issues a token, choose **Send to Sequencer** from anywhere in Burp, then say where the token is in the response. The **Token location within response** panel offers three choices: - **Cookie**, chosen from a drop-down list; the most common way to carry session tokens. - **Form field**, an HTML form field value, which suits anti-CSRF and other per-page tokens. - **Custom location**, set with the response extraction rule dialog, for tokens that are not in a usual place. **Start live capture** opens a results window where Sequencer repeatedly issues the request and extracts the token from each response, showing the number of requests made, tokens captured and errors found. You can **Pause** or **Resume**, **Stop** for good, **Copy tokens** or **Save tokens**, **Analyze now** on the current sample (a minimum of 100 captured tokens is needed), or switch on **Auto-analyze** to analyse periodically. Capture behaviour comes from project-level settings: **Number of threads** (maximum concurrent requests), **Throttle between requests** (a delay in milliseconds, so the application is not overloaded) and **Ignore token whose length deviates by X characters**. ## Manual load Under **Sequencer, Manual load** you paste tokens from the clipboard or load them from a file, for example tokens from an earlier capture. They must be in a **simple newline-delimited text format**. The display field shows the shortest and longest lengths, which is the quick check that the sample loaded the way you meant. ## Sample size | Size | What the documentation says | |---|---| | 100 | The minimum for analysis; possible, but not reliable for any serious purpose | | A few hundred | What the getting-started tutorial captures before it clicks Analyze now; fine for learning the tool | | 5,000 | Usually sufficient, although this may depend on the sample's characteristics | | 20,000 | The maximum Sequencer supports, for compliance with the FIPS standards | Results that are compliant with the formal FIPS standard need a sample of 20,000 tokens. A bigger sample raises the reliability that Sequencer reports, but it also means more requests when you capture live. ## What a live capture looks like to the owner of the application A live capture sends one request thousands of times, and where the response mints a session, each reply creates a new session record. The owner of the system under test sees: - a single client making many near-identical requests to one endpoint; - a sharp rise in session creation, with sessions that are typically never used again; - load on whatever stores sessions, and possibly slower responses for real users. A rate limiter on a session-issuing endpoint will slow or refuse a capture, and a monitoring rule on session creation will see it. The right response for the assessor is to bound the run with the thread and throttle settings, agree it with the owner in advance, and keep it inside the written scope, not to work around the control. The Sequencer getting-started page adds that the tool may give unexpected results in some applications and advises using it only against non-production systems until you are fully familiar with it. ## Where the sample can mislead - A sample is only as representative as how it was obtained: tokens captured within one window, from one source, say little about other conditions. - Variable-length tokens are padded, and Base64-encoded tokens can be decoded before analysis; both are settings that affect how the sample is read. - A sample under 5,000 may produce a reliability estimate that the report must carry along with the result. ## Common slips - Treating a 100-token result as a verdict. - Treating 20,000 as a recommended size when it is the supported maximum. - Thinking live capture is passive and leaves no trace in the application's logs. - Believing Sequencer can analyse only cookies.
- Why does Sequencer cap the sample at 20,000 tokens?The documentation says the maximum of 20,000 is for compliance with the FIPS standards. The tests page adds that to obtain results compliant with the formal FIPS standard you must use a sample of 20,000 tokens, since Sequencer otherwise adjusts the FIPS pass criteria to fit the sample you give it.
- A colleague wants to run a live capture against production on their first day with the tool. What do you tell them?The getting-started page says Sequencer can give unexpected results in some applications and to use it only against non-production systems until you are fully familiar with it. For any target the capture must be inside the written scope, agreed with the owner, and bounded with the threads and throttle settings.
- How do you check that a manually loaded sample went in the way you intended?Make sure the tokens are in a simple newline-delimited text format, then read the shortest and longest lengths shown in the display field. A surprising length range means a stray header, a blank line or a mixed format was loaded with the tokens.
- Says a 100-token sample gives a reliable verdict
- Treats 20,000 as the recommended size rather than the maximum
- Believes Sequencer can only work from a live capture
- Assumes live capture is passive and leaves no trace in server logs
- Thinks Sequencer can only analyse values held in cookies
Assumes Burp Suite Professional / Community 2026.9 documentation; the sample sizes (100 minimum, 5,000 usually sufficient, 20,000 maximum) are as that release's pages state them.