Claude Code Sends 640 Telemetry Types — This Gateway Lets You Control Them

If you’ve been using Claude Code (Anthropic’s CLI assistant), you might have noticed it sends a lot of telemetry. How much? Try 640 distinct telemetry types. That’s not a typo. From keystroke timing to request payloads, the client is chatty by default.

Most developers don’t love their local tools phoning home with that level of detail. But you also want to keep using Claude Code because it’s genuinely useful. So what can you do? Block it entirely and risk breaking updates? Or dig through opaque config files? Enter CC Gateway — a tiny proxy that lets you see, filter, and block every single piece of telemetry Claude Code tries to send.

What It Does

CC Gateway is a local HTTP reverse proxy that sits between Claude Code and Anthropic’s servers. When you run Claude Code through this proxy, every outgoing request gets intercepted. You can:

• Log all telemetry payloads in real-time (so you know exactly what’s being sent)
• Block specific telemetry types by ID or pattern
• Rate-limit or drop requests entirely
• Rewrite headers (e.g., remove user-agent or session IDs)
• Redirect telemetry to a local file or a different endpoint

Think of it like a firewall for Claude Code’s behavior — except it’s 50 lines of Rust and runs in a terminal.

Why It’s Cool

First, the number 640 is absurd. CC Gateway doesn’t just give you a binary on/off switch. It gives you a fine-grained blocklist. Want to keep crash reports but drop usage analytics? You can. Want to log everything for a week and then review which telemetry types are actually useful? Do it.

What makes this clever is the implementation. It uses a simple Rust-based TCP proxy with a TOML config file. You don’t need Docker, Kubernetes, or a PhD in networking. You write a config like:

[blocked]
types = ["keypress", "timing"]
rate_limit = 10  # requests per second

Then point Claude Code at http://localhost:8080 instead of https://api.anthropic.com. That’s it. The proxy prefixes the request URL with a X-CC-Proxy header so you can see in the logs which requests were proxied vs. blocked.

Another neat touch: because it’s a plain proxy, you can run it alongside developer tools like mitmproxy or wireshark for deeper inspection. It’s also tiny — the compiled binary is under 2MB with no runtime dependencies.

How to Try It

Clone the repo and build it (you need Rust installed):

git clone https://github.com/motiful/cc-gateway.git
cd cc-gateway
cargo build --release

Then create a config.toml:

listen_addr = "127.0.0.1:8080"
upstream = "https://api.anthropic.com"
log_file = "cc-proxy.log"
details = true

Run it:

./target/release/cc-gateway --config config.toml

Now configure Claude Code’s environment to use the proxy:

export HTTP_PROXY=http://127.0.0.1:8080
export HTTPS_PROXY=http://127.0.0.1:8080
claude

Watch the terminal — every telemetry call gets logged with its type ID and payload. Press Ctrl+C to stop, then inspect the log file to see exactly what was blocked.

There’s also a sample config with 20+ common telemetry types pre-blocked in the repo’s examples/ directory.

Final Thoughts

Claude Code is a fantastic tool, but its telemetry behavior feels like overkill for a CLI app that runs on my machine. CC Gateway is the pragmatic middle ground: you don’t have to give up the tool, but you also don’t have to blindly accept hundreds of telemetry types.

If you’re the kind of developer who likes to know exactly what your tools are doing (and you probably are, if you’re reading this), this proxy is worth trying. It’s clean, well-documented, and solves a very specific problem without pretending to be more.

Clone it, block the noise, and move on.

Follow us on X: @githubprojects