The httptoolkit-mcp server enables AI assistants to control HTTP Toolkit for intercepting, inspecting, and debugging HTTP(S) traffic across various platforms through natural language commands.
Traffic Capture & HTTP Client
Capture real-time HTTP(S) traffic (requests + responses) via WebSocket subscription
Send custom HTTP requests through the proxy with full control over method, headers, and body
Browser Interception
Launch isolated Chrome or Firefox windows with all traffic automatically routed through the proxy
Terminal Interception
Open new terminal sessions with interception enabled, or get shell commands to configure existing terminals
Docker Interception
Attach to running Docker containers to capture all outgoing HTTP traffic
Android Interception
Intercept devices/emulators via ADB
Setup and launch Frida server on Android devices
Target specific Android apps with certificate pinning bypass via Frida
iOS Interception
Intercept specific apps on jailbroken iOS devices with certificate pinning bypass via Frida
Application Interception
Attach to running JVM processes (Java/Kotlin/Clojure) via Java agent
Launch Electron applications with full traffic interception
Server & Interceptor Management
Query server version, proxy configuration (certificate paths, DNS, system proxy), and network interfaces
Trigger server updates or shut down the server
List all available interceptors and their status, retrieve detailed interceptor metadata (connected devices, running containers, JVM processes), and activate/deactivate interceptors
Enables interception of Android device traffic via ADB or specific apps via Frida, facilitating deep inspection of HTTP(S) traffic and certificate pinning bypass.
Provides the capability to attach to running Clojure processes on the JVM to intercept and inspect their outgoing HTTP traffic.
Allows for attaching to running Docker containers to capture and inspect all outgoing HTTP traffic.
Enables launching Electron applications with automated HTTP interception for debugging and traffic analysis.
Supports launching Firefox instances with traffic automatically routed through the proxy for inspection and debugging.
Enables interception of specific iOS application traffic on jailbroken devices using Frida.
Provides the capability to attach to running Kotlin processes on the JVM to intercept and inspect their outgoing HTTP traffic.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@httptoolkit-mcp launch a fresh Chrome window to intercept its traffic"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A Model Context Protocol (MCP) server that provides AI assistants with full control over HTTP Toolkit — the powerful, open-source HTTP(S) debugging proxy.
Intercept, inspect, and debug HTTP traffic from browsers, Android/iOS devices, Docker containers, JVM processes, and more — all through natural language via your AI assistant.
Live Traffic Capture — Capture intercepted HTTP traffic in real-time with full request/response headers and bodies
Browser Interception — Launch Chrome or Firefox with traffic automatically routed through the proxy
Android Interception — Intercept device traffic via ADB or target specific apps with Frida (bypasses certificate pinning)
iOS Interception — Intercept specific iOS apps via Frida on jailbroken devices
Docker Interception — Attach to running Docker containers and capture all outgoing HTTP traffic
Terminal Interception — Open intercepted terminal sessions or configure existing ones
JVM Attach — Attach to running Java/Kotlin/Clojure processes
Electron Apps — Launch Electron applications with interception enabled
HTTP Client — Send HTTP requests through the proxy with full control over method, headers, and body
Server Management — Query configuration, manage interceptors, and control the server lifecycle
Zero-Config with Desktop App — Automatically detects auth token from the running HTTP Toolkit desktop app
Related MCP server: mcp-browser-kit
HTTP Toolkit installed and running (desktop app or server)
Node.js >= 18
No installation required — just configure your MCP client:
{
"mcpServers": {
"httptoolkit": {
"command": "npx",
"args": ["-y", "httptoolkit-mcp"]
}
}
}npm install -g httptoolkit-mcpgit clone https://github.com/fdciabdul/httptoolkit-mcp.git
cd httptoolkit-mcp
npm install
npm run buildAdd to ~/.claude/settings.json or ~/.claude.json:
{
"mcpServers": {
"httptoolkit": {
"command": "npx",
"args": ["-y", "httptoolkit-mcp"]
}
}
}Add to your claude_desktop_config.json:
{
"mcpServers": {
"httptoolkit": {
"command": "npx",
"args": ["-y", "httptoolkit-mcp"]
}
}
}Variable | Description | Default |
| HTTP Toolkit management API URL |
|
| Auth token (auto-detected from desktop app) | Auto-detected |
| Mockttp admin API URL |
|
Note: When using the HTTP Toolkit desktop app, the auth token is automatically detected from the running process — no manual configuration needed.
Example with manual environment variables:
{
"mcpServers": {
"httptoolkit": {
"command": "npx",
"args": ["-y", "httptoolkit-mcp"],
"env": {
"HTK_SERVER_URL": "http://127.0.0.1:45457",
"HTK_SERVER_TOKEN": "your-token-here"
}
}
}
}Tool | Description |
| Capture live intercepted HTTP traffic with full request/response bodies. Subscribes to the active HTTP Toolkit session via WebSocket. Supports auto-detection or manual session ID. |
Tool | Description |
| Get the HTTP Toolkit server version |
| Get proxy configuration (certificates, DNS, system proxy) |
| List all network interfaces |
| Trigger a server update check |
| Shutdown the HTTP Toolkit server |
Tool | Description |
| List all available interceptors and their status |
| Get detailed metadata for a specific interceptor |
| Generic interceptor activation with custom options |
| Deactivate a running interceptor |
Tool | Description |
| Launch a fresh Chrome window with interception |
| Launch a fresh Firefox window with interception |
Tool | Description |
| Open a new terminal with interception enabled |
| Get commands to enable interception in an existing terminal |
Tool | Description |
| Attach to a running Docker container |
Tool | Description |
| Intercept an Android device/emulator via ADB |
| Set up Frida on an Android device |
| Launch Frida server on an Android device |
| Intercept a specific Android app via Frida |
Tool | Description |
| Intercept a specific iOS app via Frida |
Tool | Description |
| Attach to a running JVM process |
| Launch an Electron app with interception |
Tool | Description |
| Send an HTTP request through the proxy |
Once configured, you can ask your AI assistant things like:
"Capture the HTTP traffic from my intercepted Chrome for 10 seconds"
"List all available interceptors"
"Intercept Chrome on port 8000"
"Show me the connected Android devices"
"Attach to the Docker container running my API"
"Send a GET request to https://api.example.com/users"
"Set up Frida on my Android device and intercept the target app"
"Open an intercepted terminal session"
User: "Capture traffic from my browser for 5 seconds"
capture_traffic({ duration: 5, sessionId: "2474b580-482e-4a79-8488-121583d466e1" })
Result:
{
"capturedExchanges": 2,
"exchanges": [
{
"request": {
"method": "GET",
"url": "https://api.example.com/users",
"headers": { "host": "api.example.com", ... },
},
"response": {
"statusCode": 200,
"headers": { "content-type": "application/json", ... },
"body": "[{\"id\": 1, \"name\": \"John\"}]"
}
}
]
}┌─────────────────┐ stdio ┌──────────────────┐ REST API ┌─────────────────────┐
│ AI Assistant │◄─────────────►│ httptoolkit-mcp │◄────────────►│ httptoolkit-server │
│ (Claude, etc.) │ MCP │ (this project) │ :45457 │ (HTTP Toolkit) │
└─────────────────┘ └──────────────────┘ └─────────────────────┘
│ │
│ WebSocket ┌────────┴────────┐
│ (traffic capture) │ Mockttp Proxy │
└──────────────────────────►│ :45456 (admin) │
│ :8000 (proxy) │
└────────┬────────┘
│
┌───────────────┼───────────────┐
│ │ │
Browsers Android/iOS Docker
Devices ContainersThis project is an MCP interface for HTTP Toolkit, created by Tim Perry (@pimterry).
HTTP Toolkit — github.com/httptoolkit
HTTP Toolkit Server — github.com/httptoolkit/httptoolkit-server
Tim Perry — github.com/pimterry — Creator & maintainer of HTTP Toolkit
HTTP Toolkit is a beautiful, open-source tool for debugging, testing, and building with HTTP(S). If you find it useful, consider supporting the project.
Generic tool to activate any interceptor by ID with custom options. Use the dedicated tools (intercept_chrome, intercept_docker_container, etc.) when possible for better parameter validation.
Inputs: id (required), proxyPort (required), options.
Capture live HTTP(S) traffic being intercepted by HTTP Toolkit. Creates a temporary session, subscribes to traffic events via WebSocket, collects requests and responses for the specified duration, then returns all captured exchanges. Use this to see what HTTP requests are being made by intercepted browsers, apps, or containers.
Inputs: duration.
Deactivate a running interceptor and stop capturing its traffic
Inputs: id (required), proxyPort (required).
Intercept a specific Android app using Frida dynamic instrumentation. Automatically disables most certificate pinning. Requires a rooted device with Frida server running (use frida_android_setup and frida_android_launch first).
Inputs: proxyPort (required), hostId (required), targetId (required), enableSocks.
Launch the Frida server on an Android device. Must run frida_android_setup first.
Inputs: proxyPort (required), hostId (required).
Set up a Frida host on an Android device connected via ADB. This prepares the device for app-level interception by installing the Frida server and CA certificate.
Inputs: proxyPort (required), hostId (required).
Intercept a specific iOS app using Frida dynamic instrumentation. Automatically disables most certificate pinning. Requires a jailbroken device running Frida Server connected via USB.
Inputs: proxyPort (required), hostId (required), targetId (required), enableSocks.
Get HTTP Toolkit proxy configuration including certificate paths, network interfaces, system proxy, and DNS servers
Inputs: proxyPort.
Get detailed metadata for a specific interceptor. Returns available targets like Docker containers, Android devices, JVM processes, etc.
Inputs: id (required), subId.
List all network interfaces on the system
Inputs: no named parameters.
Get the current HTTP Toolkit server version
Inputs: no named parameters.
Intercept HTTP(S) traffic from an Android device or emulator connected via ADB. Automatically injects system HTTPS certificates into rooted devices and most emulators.
Inputs: proxyPort (required), deviceId (required), enableSocks.
Launch a fresh independent Chrome window with all HTTP(S) traffic intercepted. The browser uses an isolated profile so it won't affect your normal browsing.
Inputs: proxyPort (required).
Intercept all HTTP(S) traffic from a running Docker container. Injects proxy settings into the container to capture all outgoing HTTP traffic.
Inputs: proxyPort (required), containerId (required).
Launch an Electron application with all its HTTP(S) traffic intercepted. Use get_interceptor_metadata with id "electron" to list available Electron apps.
Inputs: proxyPort (required), pathToApplication (required).
Get a command to run in an existing terminal to start intercepting HTTP(S) traffic from processes launched in that terminal. Returns shell-specific commands for bash, zsh, fish, etc.
Inputs: proxyPort (required).
Launch a fresh independent Firefox window with all HTTP(S) traffic intercepted. Uses an isolated profile.
Inputs: proxyPort (required).
Open a new terminal window where all launched processes and Docker containers will have their HTTP(S) traffic intercepted automatically.
Inputs: proxyPort (required).
Attach to a running JVM process (Java, Kotlin, Clojure, etc.) to intercept all its HTTP(S) traffic. Uses Java agent attachment.
Inputs: proxyPort (required), targetPid (required).
List all available HTTP traffic interceptors (browsers, terminals, mobile devices, Docker, etc.) and their activation status
Inputs: proxyPort.
Send an HTTP request through the HTTP Toolkit proxy. The request will be intercepted and visible in the HTTP Toolkit UI. Returns the full response including status code, headers, and body.
Inputs: method (required), url (required), headers, body, +1 more.
Shutdown the HTTP Toolkit server. WARNING: This will stop all interception.
Inputs: no named parameters.
Trigger an update check for the HTTP Toolkit server
Inputs: no named parameters.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 23 tools
Most tools have distinct purposes, such as intercepting different targets (Chrome, Docker, Android) or managing interceptors. However, some overlap exists: 'activate_interceptor' is a generic version that could be confused with specific intercept tools like 'intercept_chrome', though descriptions clarify this. The dedicated tools are well-differentiated by target type.
Tool names follow a highly consistent verb_noun pattern throughout, such as 'activate_interceptor', 'capture_traffic', 'deactivate_interceptor', and 'list_interceptors'. All tools use snake_case uniformly, with clear verbs like 'intercept', 'get', 'list', and 'send', making the naming predictable and easy to understand.
With 23 tools, the count is slightly high but reasonable for the comprehensive scope of HTTP traffic interception across multiple platforms (browsers, mobile, Docker, terminals). Each tool serves a specific function, such as setup, activation, or management, though some consolidation might be possible without losing functionality.
The tool set provides complete coverage for HTTP Toolkit's domain, including interceptor activation/deactivation, traffic capture, platform-specific setup (Android, iOS, JVM), configuration retrieval, and server management. There are no obvious gaps; tools support the full lifecycle from setup to shutdown, ensuring agents can handle all core workflows without dead ends.
MCP server for secureFlows: token-free URL builders and integration-linting tools for AI agents.
The Mercado Pago MCP Server implements the Model Context Protocol to provide AI agents and LLMs with access to Mercado Pago's APIs and tools within compatible development environments. It acts as an intermediary that translates Mercado Pago resources into executable functions (tools) that AI applications can invoke to perform actions and automate flows. The server simplifies integration, enables using documentation to implement or improve code, and optimizes operations through natural language interactions without manual implementations.
MCP server that lets your AI assistant build and deploy apps, hosting each one at a live URL.
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
