Burp MCP

Burp MCP connects MCP-compatible clients to Burp Suite through a native Rust stdio server and a Kotlin extension built on the Montoya API. The Kotlin/Rust boundary is typed protobuf over loopback gRPC; pure transformations and persistent site data stay in Rust. Features that depend on Burp Scanner, Collaborator, or other edition-specific APIs remain capability-gated.

Architecture

Burp MCP has two runtime tiers:

1. Native Rust MCP server (burp-mcp): serves MCP over stdio and owns the bounded reconnecting gRPC client, offline utility engine, and optional project-scoped SQLite sitegraph.

2. Kotlin Burp extension (burp-mcp.jar): runs inside Burp Suite, uses the Montoya API, and exposes typed gRPC on loopback by default or remote mTLS.

┌─────────────────────────────────────────────────────────────┐
│             MCP Client (Claude, Cursor, Zed, Codex, etc.)   │
└──────────────────────────────┬──────────────────────────────┘
                               │ MCP JSON-RPC (stdio)
                               ▼
┌─────────────────────────────────────────────────────────────┐
│                 burp-mcp (Native Rust Server)               │
│  ├─ Offline Utility Decoder Engine (40+ transforms)        │
│  ├─ Optional SQLite Sitegraph Engine                        │
│  └─ Reconnecting Typed Protocol Client                      │
└──────────────────────────────┬──────────────────────────────┘
                               │ Typed Protobuf over gRPC
                               │ Loopback (127.0.0.1:9877) or Remote mTLS
                               ▼
┌─────────────────────────────────────────────────────────────┐
│            Burp MCP Extension (Kotlin / Montoya API)        │
│  ├─ Settings UI Panel (Port, Security, Certificate Rotation)│
│  ├─ Proxy, Repeater, Intruder, Scanner, WebSocket Facades   │
│  └─ Session Rules, Macros, Cookie Jar, Collaborator Engine  │
└──────────────────────────────┬──────────────────────────────┘
                               │
                               ▼
┌─────────────────────────────────────────────────────────────┐
│                    Burp Suite Desktop                       │
└─────────────────────────────────────────────────────────────┘

Related MCP server: Any-API MCP Server

Features & Capabilities

• Proxy Traffic Inspection & Triage: Search, filter (status, method, URL, regex), annotate, highlight, and view full raw HTTP/WebSocket traffic history with compact metadata by default (include_bodies: false) and smart field projection (extract_css, extract_json, headers_only, truncation).

• Logger API Integration: Complete traffic visibility across all Burp tools (Proxy, Repeater, Scanner, Intruder, Extensions) via burp_logger_history, burp_logger_detail, and burp_clear_logger.

• Organizer Integration: Send important request/response pairs directly into Burp Organizer and query/filter saved entries via burp_organizer_send and burp_organizer_list.

• Active editor UI integration: Capture and guardedly replace focused editable HTTP text editors with short-lived token/hash leases; edit WebSocket payloads through an MCP-provided extension tab with lossless Base64.

• Interception & HTTP Handlers: Toggle master proxy interception, register custom request/response modifying handlers, and configure granular proxy rules (forward, intercept, drop, edit).

• True Single-Packet Attack (Last-Byte Sync): Synchronized race condition testing via burp_race_condition (single_packet_attack: true).

• Multi-Marker Fuzzing: Advanced matrix fuzzing supporting pitchfork, cluster_bomb, and sniper attack modes via burp_inline_fuzzer.

• Collaborator Auto-Correlation Tracker: Automatic mapping between injected parameter/URL origins and out-of-band DNS/HTTP interaction callbacks.

• Response Comparer & Diffing: Compute similarity scores, header diffs, and unified line diffs between HTTP responses with burp_diff_responses and burp_send_to_comparer.

• Compound Security Workflows: High-level automated workflows for IDOR verification (burp_verify_idor), CORS auditing (burp_check_cors), and Access Control Matrix testing (burp_auth_matrix).

• Action-Based Pentesting Suite: Streamlined ~15 action-based tools for modern AI agents to dramatically reduce context-window overhead and tool hallucinations.

• Cookie Jar: Inspect, filter by domain, and set cookies within Burp's active cookie jar.

• Session Handling & Macros: Create, list, execute, update, and remove scoped session handling rules and multi-request macros with parameter extraction.

• In-Memory Payload Lists: Create, import from file/JSON/text, update, paginate, and delete named payload lists for fuzzing and Intruder attacks.

• Scanner & Crawl Automation: Launch bounded passive audits, active scans, and crawls; poll background jobs; triage and inspect issues; update issue statuses (False Positive/Ignored); and test/dry-run BCheck scripts via burp_test_bcheck.

• Sitegraph Engine (Advanced Opt-in): Project-scoped SQLite graph mapping endpoints, parameters, topology, shortest paths, clusters, downstream impact, diffs, and indexed HTTP/WebSocket evidence. Treat each graph as sensitive engagement data.

• Offline Utility Decoder Engine: 40+ built-in operations for encoding/decoding (Base64, Hex, URL, HTML, Unicode), cryptographic hashes (MD5, SHA-1/256/512, BLAKE3, HMAC), compression (Gzip, Zlib, Deflate, Brotli), JWT decoding/verification, and HTTP parsing. Some capabilities require Burp Suite Professional or a Burp feature advertised by the connected extension. The runtime tool schema and burp_burp_version.capabilities are authoritative.

Tools Inventory (43 Default + 1 SiteGraph)

Burp MCP registers 43 tools by default (42 Burp tools + 1 offline Decoder tool), plus 1 SiteGraph tool when SiteGraph is enabled with --enable-sitegraph.

1. Connection & Project Configuration (2 tools)

2. Core Pentesting Suite (13 tools)

3. Compound Security Workflows (9 tools)

4. Active UI & Desktop Editor Integration (3 tools)

5. Cookies & Findings (3 tools)

6. Background Jobs (3 tools)

7. Custom Script Imports (2 tools)

8. MCP Interception Queues (6 tools)

9. Offline Decoder Engine (1 tool)

10. Persistent Sitegraph (1 tool, Opt-in)

Requires starting the server with --enable-sitegraph or BURP_MCP_ENABLE_SITEGRAPH=true.

Installation

See the complete installation guide for supported platforms, checksum verification, Burp extension loading, MCP client configuration, optional skill installation, manual installation, and uninstall steps.

1. One-Line Installer (macOS & Linux)

Review install.sh, then install the verified native binary:

curl -fsSL https://raw.githubusercontent.com/nguyenthdat/burp-mcp/main/install.sh | bash

Install the binary plus the optional burpsuite agent skill:

curl -fsSL https://raw.githubusercontent.com/nguyenthdat/burp-mcp/main/install.sh \
  | bash -s -- --with-skill

The script detects Linux x86_64 and macOS arm64/x86_64, verifies the selected asset against SHA256SUMS, installs to ~/.local/bin/burp-mcp, and never uses sudo. Windows users should follow the manual release-asset steps in the installation guide.

2. Load the Burp Extension

1. Download burp-mcp.jar from the Latest GitHub Release.

2. In Burp Suite, navigate to Extensions > Installed.

3. Click Add, choose extension type Java, and select burp-mcp.jar.

4. The extension starts its loopback gRPC listener on 127.0.0.1:9877.

3. Verify Connection

Test that the native server connects to the loaded Burp extension:

burp-mcp probe --endpoint http://127.0.0.1:9877

MCP Client Configuration

Claude Desktop

Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "burp": {
      "command": "/Users/you/.local/bin/burp-mcp",
      "args": ["serve"]
    }
  }
}

Cursor

In .cursor/mcp.json or Global Cursor Settings:

{
  "mcpServers": {
    "burp": {
      "command": "/Users/you/.local/bin/burp-mcp",
      "args": ["serve"]
    }
  }
}

Claude Code

claude mcp add burp /Users/you/.local/bin/burp-mcp -- serve

Zed

Add to your Zed settings.json:

{
  "context_servers": {
    "burp": {
      "command": {
        "path": "/Users/you/.local/bin/burp-mcp",
        "args": ["serve"]
      }
    }
  }
}

Configuration

The Rust client reads TOML from ~/.config/burp-mcp/config.toml when that file exists. Use --config PATH or BURP_MCP_CONFIG to select another file. CLI flags and environment variables override file values. A complete starting point is config.example.toml.

Sitegraph remains opt-in: a project root or indexing mode alone does not expose its tools. Each Burp project receives an independent database. sitegraph_config is read-only; change configuration and restart burp-mcp.

Security & Remote mTLS Setup

• Local Plaintext: Plaintext gRPC is accepted only on IPv4 loopback (127.0.0.1).

• Remote mTLS: Any non-loopback endpoint requires mutual TLS (mTLS).

• The Burp extension registers Settings > Extensions > Burp MCP to generate certificates, configure SANs, and manage the TLS bundle.

~/.config/burp-mcp/tls/
├── ca.crt
├── server.crt
├── server.key       <-- Keep on Burp machine only
├── client.crt
├── client.key       <-- Copy to remote client machine (chmod 600)
└── bundle.conf

On Unix, ensure strict permissions:

chmod 700 ~/.config/burp-mcp/tls
chmod 600 ~/.config/burp-mcp/tls/client.key

For the sitegraph privacy boundary, project partitioning, daemon behavior, and retention guidance, read the sitegraph reference before enabling it.

Burp MCP is dual-use security software intended only for systems you own or are explicitly authorized to test. Treat TLS private keys, Burp traffic, sitegraph databases, Collaborator secrets, and session material as credentials or sensitive engagement data.

See CONTRIBUTING.md for development requirements. Report suspected vulnerabilities privately using SECURITY.md.

Development & Build

Requirements

• Java 25 (for extension build)

• Rust 1.88+ (for MCP binary)

• Gradle 9.7+

Building and Testing

# Build Kotlin extension JAR
gradle clean test jar

# Run Rust formatting and linter
cargo fmt --all -- --check
cargo clippy --workspace --all-targets --all-features -- -D warnings

# Run all workspace unit and contract tests
cargo test --workspace --locked

# Run gRPC interop suite
scripts/run-grpc-interop.sh

The extension JAR is written to build/libs/burp-mcp.jar. The live Burp/Pro interop scenario is local-only; see the installation guide for the release verification steps.

Releases

Published GitHub Releases contain the native MCP binary, extension JAR, checksums, and an SBOM generated from the locked Rust dependency graph.

License

Burp MCP is released under the MIT License.