skip to content

Extensions & BApps

Extensions add what Burp does not ship: BApp Store installs such as Logger++ and JWT Editor, and custom code against the Montoya API. One written for a bespoke auth scheme signals real depth.

on this pageshow

explore

questions

5

What can a Burp Suite extension see and do through the Montoya API, and why does that matter on an authorised assessment?

level: middleimportance: must knowfreq 28%

answer

  1. code, not a plugin sandbox
  2. a handler for every tool
  3. cookies and tokens in clear
  4. can send, change, drop and store
  5. the scope list is editable too

basics

~20 s

Through the Montoya API an extension can read the requests and responses of Burp's proxy and every other tool, change or send requests, and store data. It can therefore see every credential and session token that passes through Burp.

solid answer

~40 s

A Montoya extension is Java (or Kotlin) code that Burp loads and hands a `MontoyaApi` object. With it, `http().registerHttpHandler` is notified of requests and responses from **any** Burp tool, proxy handlers can modify or drop messages, `sendRequest` can send requests of its own choosing, and `scope()` can add or exclude URLs. It can also store data through `persistence()` and start OS processes through `shellUtils()`. So an extension can read every cookie, bearer token and login value that passes through Burp, and the pages describe no sandbox around it. Treat it as trusted code with the tester's rights, and read its source before it touches client traffic.

go deeper

for a junior

Recall that an extension is extra code loaded into Burp and that it can read proxied traffic. Say plainly that cookies and tokens in that traffic are visible to it.

for a middle

Explain the mechanics: initialize receives a MontoyaApi, an HTTP handler is called for every tool, and extensions can send requests, edit scope, store data and run processes. Mention the normalised HTTP/2 limit.

for a senior

Demonstrate a review: find each handler, each send and each write, check for process launching and scope edits, and re-read the diff when the extension updates.

for a principal

Frame it as data handling: the extension list and the project file are part of how client session material is protected, so the question belongs in the engagement's controls, not only the tester's habits.

## What the API puts in an extension's hands An extension is code that Burp loads and calls. As documented for Burp Suite 2026.9, in the maintained extension interface, the Montoya API, a class implements `BurpExtension` and Burp calls its `initialize` method with a `MontoyaApi` object. That object is the extension's door into Burp, and its accessors read like Burp's own tool list: `http()`, `proxy()`, `scanner()`, `scope()`, `siteMap()`, `repeater()`, `intruder()`, `collaborator()`, `persistence()`, `userInterface()`, `utilities()` and more. PortSwigger's extensions page describes the effect in plain words: an extension can modify HTTP requests and responses, send additional requests, add interface features, add checks to Burp Scanner and access information from Burp. | Hook in the Montoya API | What it gives the extension | The reviewer's question | |---|---|---| | `http().registerHttpHandler` | A callback for requests being sent and responses received by any Burp tool | What does it do with every message that passes? | | `proxy().registerRequestHandler`, `registerResponseHandler`, `proxy().history()` | Proxy messages, which a handler can modify or drop, and the stored history | Does it change or discard traffic without telling the tester? | | `http().sendRequest` | Sending any `HttpRequest` the extension builds | Which destinations does the code ever build? | | `scope().includeInScope`, `excludeFromScope` | Editing the list Burp treats as in scope | Can it widen scope beyond the written authorisation? | | `persistence().extensionData()`, `preferences()` | Storage in the project file (or memory) and in the Java preference store | Where do captured values come to rest? | | `utilities().shellUtils()` | Launching operating-system processes | Which command, built from which input? | ## Why this is a trust decision The proxy is where an assessment's credentials pass: login form values, session cookies, bearer tokens and API keys in headers. An extension with a registered handler can read all of that in clear text, from every tool and not only the one it adds a tab to. The pages in this set describe no sandbox around an extension, and the API includes `shellUtils()` for starting processes, so treat an extension as trusted code running with the tester's own rights. PortSwigger reviews what it lists in the BApp Store but states that it cannot guarantee quality or security, which is why its own advice is to read the code before installing. ## What the extension does not simply see - **Only traffic that reaches Burp.** A handler is called for messages Burp handles; traffic a client sends around the proxy never arrives. - **A normalised view of HTTP/2.** The creating-extensions page says the API gives access only to the normalised, HTTP/1-style representation of requests Burp issued, so an extension cannot modify those kettled requests, although it may send new ones with HTTP/2 formatting. - **Its own position in a chain.** Extensions process traffic in the order of the Installed list, so what a later extension receives may depend on an earlier one. ## Reading an extension as a reviewer 1. Find every registered handler and ask what it does with the whole message, not just the part the feature needs. 2. Find every place a request is built or sent, and every place data is written (the project file, the preference store, a file, a log). 3. Look for process launching and for any change to the scope list. 4. Note which Montoya API version the code was built against, then re-read the diff on every update: the API grows, and the 2026.4 changelog entry added handler abilities to suppress a request and supply a spoofed response. ## Following one message through Say a tester logs in to a staging site at example.internal while two extensions are loaded. 1. The browser sends the login request to Burp's proxy listener. 2. Burp's tools handle it, and every registered HTTP handler is called with the whole request, including the form values and any `Authorization` or `Cookie` header. 3. Proxy handlers may also change or drop it before it moves on. 4. The response comes back with a session cookie, and the handlers are called again. 5. An extension that stores what it saw may write it into the project file, so the cookie can outlive the session it belonged to. Nothing in that flow asks the tester whether an extension may read the cookie. The decision was made when the extension was installed, which is why the vetting step carries the weight. ## What an assessment owner should expect An authorised test does not end at the target. The tester's laptop holds a copy of the client's session material, so the extension list is part of how that material is protected. Name the extensions in use, say why each is there, and keep project files that hold captured traffic under the same handling as the report.

  • A reviewer finds a call to `shellUtils().execute` in an extension's source. What does that tell them, and what do they check?
    The extension can start operating-system processes from inside Burp with the tester's rights. The API names its single-string variant `dangerouslyExecute` and warns against passing arbitrary input to it. The reviewer checks which program is launched, what input reaches it, and whether the feature genuinely needs it.
  • Does an extension receive HTTP/2 traffic exactly as it went over the wire?
    No. PortSwigger's creating-extensions page says the API exposes only the normalised, HTTP/1-style form of requests Burp issued, so an extension cannot modify those kettled requests. It may send new requests with HTTP/2 formatting. A reviewer should not assume an extension's log is a byte-accurate record.
  • Where might values an extension captured end up after the engagement, and why does that matter for the project file?
    `persistence().extensionData()` stores into the Burp project file, or memory when no project file is used, and `preferences()` uses the Java preference store, which survives reloads of the extension and of Burp. A saved project can therefore carry captured credentials, so handle it like the report's evidence and delete it on schedule.

Installing an extension is like seating a subcontractor at the mail desk of the engagement: they can read every envelope that passes, add their own, and keep copies, so you vet the person before the seat.

  • Extensions are sandboxed and cannot read proxied credentials.
  • A BApp Store listing means PortSwigger guarantees the extension is safe.
  • An extension only sees traffic from the tool it adds a tab to.
  • Extensions can read the Proxy history but cannot send requests of their own.
  • Burp's scope list cannot be changed by an extension.

Assumes Burp Suite Professional / Community 2026.9 and the Montoya API at its 2026.7 tag; the API gains abilities between releases (2026.4 added suppressing a request and supplying a spoofed response).

open as a page

In Burp Suite, when would you write a Bambda instead of a full extension, and what risk do Bambdas still carry?

level: juniorimportance: should knowfreq 16%

basics

~20 s

A Bambda is a small Java script run inside Burp for table filters, custom columns and match-and-replace rules, needing no project setup. Complex features call for an extension. A Bambda still runs arbitrary code, so review imported ones.

open as a page

Before a tester installs an extension from Burp's BApp Store, what does its listing tell you, and where does that evidence stop being trustworthy?

level: seniorimportance: should knowfreq 12%

basics

~20 s

A listing shows description, author, version, source link, updated date, community rating, popularity and estimated system impact. None is a security audit: PortSwigger reviews submissions but guarantees neither quality nor security, so read the source.

open as a page

In Burp Suite, how do the Montoya API and the legacy Extender API differ, and what does that mean for an inherited Jython extension?

level: middleimportance: nice to knowfreq 9%

basics

~20 s

The Montoya API, used from Java or Kotlin, is the actively maintained, recommended interface. The legacy Extender API (Python via Jython, Ruby via JRuby) is no longer actively maintained, so inherit one only with review and a port-or-retire plan.

open as a page

What would you put in a team policy governing which Burp extensions and Bambdas assessors may install on their testing laptops?

level: principalimportance: nice to knowfreq 5%

basics

~10 s

Treat extensions and Bambdas as code that sees client credentials: a named, versioned allow-list reviewed from source, controlled install paths, an update rule, handling for project files and an inventory per engagement.

open as a page