Expose localhost. Inspect everything. Replay anything.

One small Go binary that tunnels public traffic to your machine, lets you watch, rewrite, break and replay requests, and diff two implementations side by side.

Start your first tunnel
$routa dev 3000
0
inbound ports
4040
dashboard
1
Go binary
routa — zsh
$ ▋

Live inspector

Every request in, fully inspectable, one click from replay.

Try the filters — this is the same split-view the dashboard gives you at localhost:4040.

localhost:4040 · live stream
methodpathstatusms
GET /api/v1/users/8821req_8821
200
status
12ms
total
1.2ms
proxy
timing breakdown12ms
● proxy● upstream● response
{
  "id": 8821,
  "email": "ada@lovelace.dev",
  "plan": "pro"
}
ReplayEdit & Replay

Architecture

One outbound connection carries everything.

Your machine never accepts an inbound connection. The agent holds an encrypted WebSocket open to the relay, the relay maps a generated hostname to that tunnel, and the inspection layer observes traffic without altering normal request and response behaviour.

step 1
Internet
https://a7x3.routa.suyashx.dev
step 2
Routa Relay
public edge · :8080
step 3
Routa Agent
outbound ws tunnel
step 4
Local service
127.0.0.1:3000
Dashboard UI
embedded SPA on :4040
Mutation & simulator
middleware pipeline
Webhook lab
provider detection

Capabilities

Tunneling is the easy part. Control is the point.

Tunneling & relay

A persistent outbound WebSocket to a self-hosted relay: multiplexed frames, heartbeats and automatic reconnect. No inbound port, no firewall changes.

Live traffic inspector

Requests stream into localhost:4040 in real time with full headers, bodies, query params, status and a timing breakdown you can search and filter.

Replay & edit-replay

Re-fire any captured request, or change method, URL, headers and JSON body inline first. Replays are tagged and linked to their parent request.

Webhook lab

Point Stripe, GitHub, Shopify, Discord, Slack, Twilio, SendGrid or PayPal at a generated endpoint. Provider and signature headers are detected automatically.

Multi-service routing

Declarative patterns like /api/v1/* and /auth/* fan a single public URL out across as many local microservices as you run.

Failure simulator

Fixed or jittered latency, configurable error rates, forced status codes, dropped connections and artificial timeouts on the routes you choose.

Shadow traffic & deep diff

Mirror live traffic to a second implementation and compare status, headers and nested JSON bodies side by side before you ship the rewrite.

Sessions & playback

Save request collections as JSON fixtures and replay whole interactions in order, with the original delays preserved.

Guarded exposure

Access tokens, named tunnels, expiry rules and an instant kill switch — plus redaction of secrets before anything is written to disk.

Quick start

Three steps to a public URL.

  1. 1
    Install the binary
    go install github.com/7uyash/routa/cmd/routa@latest

    Go 1.21+, or grab a release build.

  2. 2
    Run it against your port
    routa dev 3000

    Node, Go, Python, Rails — anything serving HTTP locally.

  3. 3
    Open the dashboard
    http://localhost:4040

    Traffic starts streaming immediately.

Read the full user guide
routa.yamldeclarative
routes:
  - path: "/api/v1/users/*"
    target: "http://localhost:8081"
mutations:
  - name: "Inject Debug Header"
    request:
      set_headers:
        X-Debug-Mode: "true"
simulations:
  - latency_ms: 250
    error_rate: 0.1
shadows:
  - shadow_url: "http://localhost:9090"
    compare_response: true

Reproduce the bug whenever you want.

Capture a real webhook once, save it as a fixture, and replay the whole sequence on demand — no provider, no waiting, no flaky reproduction steps.

Clone the repoBrowse the docs