Introduction

HTTPeep is a fast, cross-platform HTTP/HTTPS debugging proxy built with Rust and Tauri. It sits between your application and the internet, capturing and decrypting every request so you can inspect, modify, mock, and replay traffic — all through a composable rule engine you configure once and reuse forever.

Quick links

How HTTPeep works

Who HTTPeep is for

HTTPeep is designed for developers and QA engineers who regularly need to understand or change network behavior without modifying application code:

• Frontend developers mocking API responses while the backend is in development
• Full-stack developers routing production traffic to a local service for integration testing
• QA engineers simulating slow networks, random failures, and edge-case responses
• DevOps and CLI users scripting proxy operations or integrating debugging into CI/CD workflows

Key differentiators

HTTPeep takes a different approach from most HTTP debuggers:

Rule as Code. Every rule you create is a YAML file stored at ~/.httpeep/rules/. You can version-control your debugging configurations, branch them per project, and share them with your team via Git. Other tools store rules in opaque databases or project files that don't travel well.

Persistent, composable rules. Each rule follows a deterministic Match → Actions → Resolve → Response pipeline. You combine conditions and actions freely, then save the result as a reusable asset — not a one-off intercept that disappears when you close the session.

Terminal UI with full feature parity. httpeep-cli ships bundled with the desktop app and provides a fully featured TUI powered by ratatui. Rule configuration, traffic capture, and breakpoint debugging all work over SSH or in headless environments.

AI and MCP integration. A built-in MCP server lets AI agents like Claude, Cursor, and GitHub Copilot query live session data, generate mock rules, and analyze abnormal requests directly.

Linux support. HTTPeep runs natively on Linux (glibc 2.31+) including headless servers via the CLI, a gap left by several competing tools.

One-time pricing. The Professional tier is a single $59 purchase with no subscription.

Local data only. All captured traffic and configuration is stored at ~/.httpeep/. Nothing is sent to external servers.

Core features

Rule as Code

Rules are plain YAML files stored in ~/.httpeep/rules/. This means your debugging configurations work like source code: you can track changes, create branches for different environments, and review rule updates through pull requests.

~/.httpeep/rules/
├── rule.yaml           # Rule configuration
├── bypass.yaml         # Bypass configuration
├── dns_override.yaml   # DNS override configuration
├── external_proxy.yaml # External proxy configuration
└── rate_limit.yaml     # Rate limit configuration

A typical rule looks like this:

- id: rule_mnhi5xkt
  description: "Frontend Mock API"
  enabled: true
  builtin: false
  stopAfterMatched: false
  match:
    domains:
      - type: exact
        value: api.example.com
    originProtocol: https
  requestActions: []
  resolve:
    type: map_local_dir
    filePath: /Users/chris/mocks/api
    headers:
      x-httpeep-debug: '1'
  responseActions:
    - type: delay_response
      id: action_1775140499860
      enabled: true
      delayMs: 500

The team collaboration workflow follows naturally: save personal rules to a local Git repository, sync shared rules via a remote repository, use branches for different project rule sets, and review changes through pull requests.