NullWire MCP server
Commit Nov 15, 2026Lets an AI assistant debug HTTP, HTTPS, and WebSocket traffic by providing scrubbed, secret-free network logs via a RAM-only proxy.
Also known as VoxNode-ux/nullwire-mcp
- Stars
- 0
- Tools
- 3
- Downloads, 30 days
- —
- Latest version
- 1.2.0
- Last commit
- Nov 15, 2026
- License
- MIT
What is NullWire MCP?
NullWire lets an AI assistant debug HTTP, HTTPS, and WebSocket traffic by providing scrubbed, secret-free network logs via a RAM-only proxy. It exposes 3 tools, such as inspect_traffic, export_sanitized_curl, clear_ram_buffer.
Summary generated from the project's README
About NullWire MCP server
Debugging network traffic with an AI assistant becomes safer when you can provide logs without exposing sensitive credentials. NullWire-MCP acts as a RAM-only proxy that sits between your application and the network to capture HTTP, HTTPS, and WebSocket traffic. It creates a scrubbed copy of every request and response, ensuring that private keys, session cookies, and authorization headers are redacted before they reach the model. Because it operates entirely in memory and writes nothing to disk, it maintains a high security standard for local development.
Developers can use this server with various MCP clients like Claude Desktop, Cursor, or VS Code. It offers multiple capture modes, including a forward proxy, a blind HTTPS tunnel, and a reverse gateway for full visibility into encrypted traffic. The server provides specific tools such as inspect_traffic to view recent flows, export_sanitized_curl to generate safe replay commands, and clear_ram_buffer to wipe the memory. This setup allows an AI to analyze why an API call failed without ever seeing the actual secrets used in the transaction.
What you can do with it
- 1Debug failed API requestsAsk your AI assistant to analyze recent network flows to identify why a specific request returned an error code.
- 2Replay requests safelyGenerate a curl command from a captured flow that uses environment variables instead of raw secrets.
- 3Inspect WebSocket communicationMonitor bidirectional text messages sent over a WebSocket connection for debugging real-time data.
- 4Analyze encrypted HTTPS trafficUse a reverse gateway to gain full visibility into HTTPS request and response bodies without installing custom certificates.
Written from the project's README. Every use case is checked against a quote from it.
NullWire MCP tools 3
Detected from the READMEinspect_trafficexport_sanitized_curlclear_ram_buffer
| inspect_traffic | — | |
| export_sanitized_curl | — | |
| clear_ram_buffer | — |
Configuration
ANTHROPIC_BASE_URLCGO_ENABLEDOPENAI_BASE_URL
| Name | Description | |
|---|---|---|
| ANTHROPIC_BASE_URL | — | |
| CGO_ENABLED | — | |
| OPENAI_BASE_URL | — |
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachablevoxnode-ux/nullwire-mcp is public and reachablegithub.com/voxnode-ux/nullwire-mcp ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-13github.com/voxnode-ux/nullwire-mcp ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model3 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNo tool named like delete, drop or execPass
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHub⚡ NullWire-MCP
See the traffic. Never the secrets.
A zero-dependency, RAM-only network inspector that lets your AI assistant debug HTTP, HTTPS and WebSocket traffic, with every secret scrubbed before the model ever sees it.
Quick start · How it works · What gets redacted · MCP tools · Configuration · CLI reference · Security model
🧠 Why NullWire exists
Your AI assistant is great at debugging an API call, until the request it needs to read carries an Authorization header, a session cookie, a database URL or a customer's email. Pasting raw traffic into a chat means pasting your secrets with it.
NullWire sits between your app and the network. It records what passes through, scrubs every secret out of the recorded copy, and hands that clean copy to your assistant through the Model Context Protocol. Your app keeps working exactly as before, because the live traffic is never touched.
your app ──► NullWire (127.0.0.1) ──► the real server
│
├─ forwards every byte, unmodified
└─ keeps a scrubbed copy in RAM ──► your AI assistant (MCP)
✨ At a glance
| 🪶 Zero dependencies | Go standard library only. One static binary, nothing to install. |
| 🧠 RAM only | The last 50 flows live in memory. The server never writes a file, and a stop signal wipes the buffer. (install edits your MCP client configs, but only when you run it.) |
| 🔒 Loopback only | The proxy binds to 127.0.0.1. A DNS-rebinding guard answers only loopback Host headers. |
| 🧽 Layered redaction | Private keys, JSON/XML/query secrets, JWTs, 50+ vendor key formats, IPs, secrets hiding in base64, and a randomness detector for keys nobody has seen before. |
| 🛡️ Fail-closed shields | Bodies that can't be inspected are refused or flagged, never silently passed to the model. |
| 🔌 HTTP, HTTPS and WebSocket | Plain proxying, blind CONNECT tunnels, a reverse gateway for full HTTPS visibility, and WebSocket text capture in both directions. |
| 🔁 Safe replay | Export any captured request as a curl command with secrets swapped for environment variables. |
| 🔎 Secret scanner | scan and protect look for secrets in your MCP configs, .env, TOML, YAML and ZIP files before they leak. |
| 📱 Runs anywhere | Linux, macOS, Windows, Docker and Termux on Android. |
🚀 Quick start
1. Install it
Pick whichever fits your machine. Every method checks the download against the release's SHA256SUMS.txt and installs nothing if it doesn't match. Release binaries also carry signed GitHub build provenance, and each release includes a CycloneDX SBOM (nullwire-sbom.cdx.json).
npx -y nullwire-mcp install --client all
Nothing to download by hand: the launcher fetches and verifies the binary on first run and keeps it in a cache folder. Your MCP clients are then set to run npx -y nullwire-mcp.
curl -fsSL https://raw.githubusercontent.com/VoxNode-ux/nullwire-mcp/main/scripts/install.sh | sh -s -- --setup
Installs to ~/.local/bin (or $PREFIX/bin on Termux). --setup also registers NullWire with your MCP clients. Drop it to install only. --uninstall removes everything again.
irm https://raw.githubusercontent.com/VoxNode-ux/nullwire-mcp/main/scripts/install.ps1 | iex
nullwire-mcp install --client all
Installs to %LOCALAPPDATA%\Programs\nullwire-mcp and adds it to your user PATH. To pass options, run it as & ([scriptblock]::Create((irm https://raw.githubusercontent.com/VoxNode-ux/nullwire-mcp/main/scripts/install.ps1))) -Setup.
brew install VoxNode-ux/nullwire/nullwire-mcp # macOS, Linux
scoop bucket add nullwire https://github.com/VoxNode-ux/scoop-nullwire # Windows
scoop install nullwire-mcp
Both packages are generated from the templates in packaging/.
| Platform | File |
|---|---|
| Linux x86-64 / ARM64 (Raspberry Pi 4+, Termux) | nullwire-linux-amd64 / nullwire-linux-arm64 |
| Linux ARMv7 (older Raspberry Pi) / RISC-V 64 | nullwire-linux-armv7 / nullwire-linux-riscv64 |
| macOS Intel / Apple Silicon | nullwire-darwin-amd64 / nullwire-darwin-arm64 |
| Windows x86-64 / ARM64 | nullwire-windows-amd64.exe / nullwire-windows-arm64.exe |
| FreeBSD x86-64 | nullwire-freebsd-amd64 |
chmod +x nullwire-linux-amd64
sha256sum -c SHA256SUMS.txt --ignore-missing # verify the download (macOS: shasum -a 256 -c)
gh attestation verify nullwire-linux-amd64 --repo VoxNode-ux/nullwire-mcp # optional: verify signed build provenance
go install github.com/VoxNode-ux/nullwire-mcp@latest
# or
git clone https://github.com/VoxNode-ux/nullwire-mcp && cd nullwire-mcp
CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o nullwire-mcp .
Go 1.26 or newer. There is nothing to go get: the module has no dependencies.
docker run -i --rm ghcr.io/voxnode-ux/nullwire-mcp
The server speaks MCP over stdio, so run it with -i. The proxy listens on the container's own loopback by design, so a published port (-p) cannot reach it. On Linux, add --network host to use it from the host's 127.0.0.1.
2. Add it to your MCP clients
One command registers NullWire with every supported client it finds on your machine:
nullwire-mcp install --client all --dry-run # look first: nothing is written
nullwire-mcp install --client all # then do it, and restart the client
It covers Claude Desktop, Claude Code, Cursor, Windsurf, VS Code, Cline, Roo Code, Gemini CLI and Codex CLI. See Connect your MCP clients for details, or add it by hand:
# Claude Code
claude mcp add nullwire -- /path/to/nullwire-mcp
// Claude Desktop, Cursor, Windsurf, Cline and other JSON-configured clients
{
"mcpServers": {
"nullwire": {
"command": "/path/to/nullwire-mcp",
"args": ["-port", "8080"]
}
}
}
The client starts NullWire, and NullWire starts the proxy in the same process. A live status bar on stderr shows what is happening:
⚡ [NullWire-MCP] Proxy 127.0.0.1:8080 | RAM Ring: 3/50 | Scrubbed: 7 Tokens, 2 Cookies, 1 IPs | Disk: 0B
3. Send some traffic through it
# Plain HTTP through the proxy
curl -x http://127.0.0.1:8080 http://httpbin.org/headers
# HTTPS through the proxy (a blind tunnel, see "How it works")
curl -x http://127.0.0.1:8080 https://example.com
# HTTPS with full request visibility: the reverse gateway
nullwire-mcp -target https://api.example.com
curl http://127.0.0.1:8080/v1/things -H "Authorization: Bearer sk-live-..."
4. Ask your assistant
"Use
inspect_trafficto show my last 5 requests and tell me why the third one returned 401."
🔭 How it works
flowchart LR
A[Your app or curl] -->|HTTP_PROXY / base URL| P[NullWire proxy<br/>127.0.0.1:8080]
P -->|unmodified bytes| S[(Real server)]
S -->|unmodified bytes| P
P --> C[Capture copy]
C --> R[Redaction layers]
R --> B[(RAM ring<br/>50 flows)]
B -->|MCP over stdio| M[AI assistant]
The key idea: the model reads a scrubbed copy, your app talks to the real server. Nothing the proxy forwards is rewritten, so debugging never changes the behaviour you are debugging.
Four ways to capture traffic
| Mode | How you use it | What the assistant sees |
|---|---|---|
| Forward proxy | HTTP_PROXY=http://127.0.0.1:8080 and http:// URLs |
Full request and response, scrubbed |
| HTTPS tunnel | HTTPS_PROXY=http://127.0.0.1:8080 (CONNECT) |
Only the target host:port, timing and byte counts. The encrypted payload is never opened. |
| Reverse gateway | Point your app's base URL at http://127.0.0.1:8080 and start with -target https://… (or send an X-Target-URL header) |
Full HTTPS request and response, scrubbed. NullWire makes the TLS connection to the real server. |
| WebSocket | Any Upgrade: websocket request through either proxy mode |
Text messages in both directions, scrubbed, as one flow recorded when the connection closes. Frames are forwarded unmodified. |
Why no HTTPS interception? Reading HTTPS from a forward proxy would require a custom root certificate installed on your machine. That is key material and a trust-store change, the opposite of a zero-footprint tool. The reverse gateway gets you the same visibility with no certificate games.
Several APIs at once
Give each upstream a name. The first path segment picks the upstream and is removed before forwarding:
nullwire-mcp -target openai=https://api.openai.com,anthropic=https://api.anthropic.com
export OPENAI_BASE_URL=http://127.0.0.1:8080/openai/v1 # → https://api.openai.com/v1
export ANTHROPIC_BASE_URL=http://127.0.0.1:8080/anthropic # → https://api.anthropic.com
Names are letters, digits, ., _ and - (up to 32 characters, case-insensitive). One unnamed URL may be added as the default for paths that match no name. An X-Target-URL header overrides everything for a single request.
🧰 MCP tools
NullWire exposes three tools over stdio. It speaks MCP protocol versions 2026-07-28, 2025-11-25 and 2024-11-05, and accepts JSON-RPC batches.
| Tool | What it does | Arguments |
|---|---|---|
inspect_traffic |
Returns recent scrubbed flows. | limit (1 to 50, default 10), method, url_filter |
export_sanitized_curl |
Rebuilds a captured request as a curl command. Redacted values become environment variables you fill in yourself. |
flow_id (required) |
clear_ram_buffer |
Wipes all 50 slots and resets the counters. | none |
A flow looks like this (illustrative):
{
"id": 7,
"timestamp": "2026-10-31T09:14:02Z",
"method": "POST",
"url": "https://api.example.com/v1/charge",
"request_headers": { "Authorization": "[REDACTED_TOKEN#a1b2c3]", "Content-Type": "application/json" },
"request_body": "{\"card_token\":\"[REDACTED_TOKEN#9f3e21]\",\"amount\":4200}",
"status_code": 401,
"response_body": "{\"error\":\"invalid_api_key\"}",
"latency_ms": 143,
"redaction_count": 2
}
Tags are stable and correlatable. [REDACTED_TOKEN#a1b2c3] is a short salted hash, so the same secret gets the same tag everywhere in one run. Your assistant can see that two requests used the same token without learning it. The salt is random per run, so tags can't be compared across restarts or reversed.
Tag kinds: TOKEN, COOKIE, IP and KEY (private keys).
export_sanitized_curl produces something like:
# Replay of flow 7
# Set environment variables first:
# export NULLWIRE_AUTH_TOKEN=... # was [REDACTED_TOKEN#a1b2c3]
curl -X POST 'https://api.example.com/v1/charge' \
-H "Authorization: $NULLWIRE_AUTH_TOKEN" \
-H 'Content-Type: application/json' \
--data-raw '…'
Placeholders are NULLWIRE_AUTH_TOKEN, NULLWIRE_COOKIE, NULLWIRE_IP and NULLWIRE_PRIVATE_KEY. CONNECT tunnels have no replayable request, and NullWire says so.
🧽 What gets redacted
Every URL, header, request body and response body passes through these layers, in this order:
| # | Layer | Catches | Example |
|---|---|---|---|
| 1 | Private keys | PEM blocks: RSA, EC, OpenSSH, encrypted, PGP; JSON-escaped ones; blocks cut off by a size limit | -----BEGIN PRIVATE KEY-----… |
| 2 | Secret fields | JSON string values and arrays, and query parameters, for names like password, api_key, access_token, secret, session_id |
"password": ["a","b"], ?api_key=… |
| 3 | XML elements | Element text for secret-looking names, with namespaces and CDATA; the tags themselves stay intact | <wsse:Password>…</wsse:Password> |
| 4 | URL credentials | user:password@host in any URL or connection string |
postgres://app:pw@db/prod |
| 5 | Auth schemes | Bearer, Basic and Token credentials |
Authorization: Bearer … |
| 6 | JWTs | Three-part eyJ… tokens |
|
| 7 | Vendor keys | 50+ formats in three tiers (below) | AKIA…, ghp_…, sk-ant-…, SG.… |
| 8 | Secret-named fields | key: value or key=value pairs where the name says secret and the value is 12 to 256 characters |
x-custom-auth: …, session=… |
| 9 | Your patterns | Regexes from the config file | |
| 10 | IP addresses | IPv4 (strictly validated) and IPv6, except loopback and unspecified | 203.0.113.9 |
| 11 | Base64 | Base64 or URL-safe base64 whose decoded text contains a secret. Images and other binary data are left alone. | eyJhcGlfa2V5… |
| 12 | Randomness detector | 16 to 128 character tokens that look machine-generated: mixed case or digits, high Shannon entropy, few vowels. UUIDs are exempt. | an unknown vendor's key |
Headers. Authorization, Cookie, Set-Cookie, X-Api-Key, Api-Key, X-Auth-Token and Proxy-Authorization are always redacted, plus any you add.
Vendor tiers. Matching all prefixes the same way would redact ordinary words, so they are tiered:
| Tier | Needs after the prefix | Examples |
|---|---|---|
| Strong | 16+ token characters | sk-ant-, sk-proj-, AKIA, ASIA, ghp_, github_pat_, glpat-, xoxb-, sk_live_, sk_test_, rk_live_, npm_, SG., AIza, ya29., pplx- |
| Weak (also occur in normal words) | 20+ characters, plus a digit, a capital or 24+ characters | hf_, r8_, secret_, api_key_, access_token_, bearer , token |
| Connection strings | 8+ characters | postgres://, mysql://, mongodb+srv://, redis://, amqp:// |
Prefixes are matched case-sensitively, so asiapacific_region is left alone.
Bodies are decoded before scrubbing. gzip and deflate (up to 1 MiB expanded, a decompression-bomb guard). multipart/form-data forms are split into fields; file parts keep only the field name, file name and size.
🛡️ Safety shields
| Shield | Behaviour |
|---|---|
| Request shield | A request body with a Content-Encoding NullWire can't read (br, zstd, stacked encodings) is refused with 415, because a body that can't be scrubbed must not reach the model. -allow-uninspectable forwards such requests anyway. |
| Response shield | The client's Accept-Encoding is cut down to gzip and deflate before it reaches the server, so servers never answer in Brotli or Zstd. A client that offers nothing usable gets identity. |
| Unreadable bodies | Any other encoded body is stored as a short placeholder with a visible warning in the flow's note. |
| Protobuf and gRPC | Binary bodies are not stored. Only their size is recorded. |
| Size limits | See the table below. A secret that straddles a limit is still scrubbed first, thanks to an 8 KiB scrub window. |
| Loopback only | The proxy binds to 127.0.0.1. The reverse gateway answers only loopback Host headers (403 otherwise) and refuses to proxy to itself (508). |
| Tunnel limits | At most 256 concurrent tunnels and upgraded connections, each closed after 10 minutes idle. |
| Wipe on exit | SIGINT and SIGTERM clear the ring buffer before the process exits. |
Limits
| What | Limit |
|---|---|
| Flows kept in RAM | 50 |
| Stored request body | 32 KiB |
| Stored response body | 256 KiB |
| In-flight capture buffer | 64 KiB request, 512 KiB response |
| Scrub window past the stored size | 8 KiB |
| Decoded gzip/deflate | 1 MiB |
| Randomness detector | 16 to 128 characters |
⚙️ Configuration
Pass -secrets-config path/to/file.json to tune redaction without recompiling. Every field is optional.
{
"sensitive_headers": ["X-Company-Auth", "X-Api-Signature"],
"ignore_url_substrings": ["/healthz", "/metrics"],
"ignore_headers": ["User-Agent"],
"custom_vendors": [
{ "name": "Internal DB", "prefix": "db_prod_", "pattern": "" },
{ "name": "Acme Auth", "prefix": "acme_", "pattern": "acme_[a-zA-Z0-9]{32}" }
],
"extra_regex_patterns": [
{ "name": "app_key", "pattern": "app_k_[a-zA-Z0-9]{24}" }
]
}
| Field | Effect |
|---|---|
sensitive_headers |
Header values that are always redacted, like Authorization. -scrub-headers a,b adds more from the command line. |
ignore_url_substrings |
Flows whose URL contains one of these are never recorded (health checks, metrics). |
ignore_headers |
Header values that are left as they are. |
custom_vendors |
prefix redacts anything with 8+ token characters after it. pattern is an optional full regex. |
extra_regex_patterns |
Extra regexes; every match is redacted. |
Patterns use Go's RE2 syntax, which runs in linear time, so a bad pattern cannot freeze the proxy.
🔌 Connect your MCP clients: install
install writes NullWire into your MCP clients' config files, and removes it again, so you never have to hunt for the right file or JSON key.
nullwire-mcp install --list # supported clients and whether they are here
nullwire-mcp install --client all --dry-run # preview every change
nullwire-mcp install --client cursor,vscode # just these two
nullwire-mcp install --client cursor -- -port 8081 # save server flags with the entry (after --)
nullwire-mcp install --uninstall --client all # take it back out
nullwire-mcp install --print # a snippet to paste into clients that aren't supported
| Client | --client |
What it edits |
|---|---|---|
| Claude Desktop | claude-desktop |
claude_desktop_config.json in your user config folder |
| Claude Code | claude-code |
runs claude mcp add --scope user (needs the claude command) |
| Cursor | cursor |
~/.cursor/mcp.json |
| Windsurf | windsurf |
~/.codeium/windsurf/mcp_config.json |
| VS Code (Copilot) | vscode |
your user mcp.json |
| Cline | cline |
cline_mcp_settings.json |
| Roo Code | roo |
mcp_settings.json |
| Gemini CLI | gemini |
~/.gemini/settings.json |
| Codex CLI | codex |
~/.codex/config.toml ([mcp_servers.nullwire]) |
Other clients (Zed, Continue, JetBrains and more) are not edited. Use --print and paste the snippet where that client keeps its MCP servers.
How it stays safe
- With
--client allit only touches clients it finds on your machine. Name a client explicitly to create its config. - The first time it changes a file it keeps a copy next to it as
<file>.nullwire-bak. That copy is never overwritten, so it always holds the original. - Files are written through a temporary file and renamed, and symlinked dotfiles stay symlinks.
- Your other servers, settings, numbers and extra fields on the NullWire entry (such as
env) are kept. JSON keys may be re-ordered. - A config it can't parse as plain JSON (for example one with comments) is left alone, with a clear message.
- Running it twice changes nothing the second time.
| Option | Meaning |
|---|---|
--client |
Comma-separated client ids, or all (default). |
--name |
Name to register the server under (default nullwire). |
--binary PATH |
Register this binary instead of the one that is running. |
--npx |
Register npx -y nullwire-mcp (used automatically when you started it through npx). |
--dry-run, --uninstall, --list, --print |
As described above. |
-- … |
Everything after -- is saved as the server's own flags. |
🔎 Scan your machine: scan and protect
Secrets leak long before traffic does: a token in an MCP config, a password in .env. NullWire can find them. Scanning never writes to disk and never prints a secret: findings are shown already scrubbed, and shell history text is never shown at all.
nullwire-mcp scan --discover # known MCP client configs, ~/.env, ~/.codex/config.toml, …
nullwire-mcp scan .mcp.json .env # specific files
nullwire-mcp scan --deep ./my-project --toml --yaml --zip
nullwire-mcp scan --history # opt-in: count secrets in shell history
| Option | Meaning |
|---|---|
--discover |
Check the usual config locations under your home and config directories. |
--deep DIR |
Walk a directory for MCP config JSON and .env files. Skips node_modules, .git, dist, build, vendor and similar by exact folder name. |
--toml, --yaml, --zip |
Also scan *.toml, *.yaml/*.yml and ZIP archives. Off by default so a deep scan doesn't open every CI file. |
--history |
Count lines with secrets in bash, zsh, fish and PowerShell history. Text is never printed. |
| exit codes | 0 done, 1 every file failed to scan, 2 bad usage |
File types are recognised by name, so nullwire-mcp scan some.env config.toml settings.yaml bundle.zip routes each to the right scanner. Files over 4 MiB are skipped. ZIP archives are read in memory under a zip-bomb shield: entries over 1 MiB, archives over 20 MiB of content or 1000 entries are skipped and reported.
protect runs a quick scan of the usual places, then starts the normal server:
nullwire-mcp protect --target https://api.example.com --deep .
It accepts the server options (--port, --target, --cacert, --dns, --secrets-config, --scrub-headers, --allow-uninspectable) plus --deep DIR, --history and --no-scan. The scan report goes to stderr, so the MCP channel on stdout stays clean, and stop signals are passed on to the server.
📟 CLI reference
nullwire-mcp [flags] run the MCP server and the proxy
nullwire-mcp scan [options] [PATH…] look for secrets in files
nullwire-mcp protect [options] scan, then run the server
nullwire-mcp install [options] register NullWire with your MCP clients
| Flag | Default | Meaning |
|---|---|---|
-port |
8080 |
Proxy port. Always bound to 127.0.0.1. |
-target |
none | Reverse-gateway upstream: a URL and/or name=URL entries, comma-separated. |
-cacert |
none | Extra CA certificates (a PEM file or a directory) for upstream HTTPS. |
-dns |
auto |
Upstream DNS: auto, system, or a comma list of IPs such as 1.1.1.1,9.9.9.9:53. |
-secrets-config |
none | Path to the JSON config. |
-scrub-headers |
none | Extra header names to always redact. |
-allow-uninspectable |
off | Forward request bodies that can't be inspected instead of refusing them with 415. |
NullWire MCP questions
What tools does NullWire MCP provide?
It exposes 3 tools, including inspect_traffic, export_sanitized_curl, clear_ram_buffer.
How does NullWire protect my secrets?
It sits between your app and the network, recording traffic and scrubbing every secret out of a copy before handing that clean copy to the AI assistant.
Does this tool write data to my disk?
No, it is a RAM-only inspector that keeps the last 50 flows in memory and never writes a file.
What kind of secrets are redacted?
It redacts private keys, JSON/XML/query secrets, JWTs, over 50 vendor key formats, IPs, and secrets hidden in base64.