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.

Zero-config discovery

Scan local ports, identify running HTTP services and propose safe routing rules before traffic reaches the wrong backend.

Automatic API mapping

Turn observed traffic into a living endpoint map with normalized paths, request volume, latency and error-rate context.

1-click mock lab

Convert a captured response into an editable mock, tune its status, body and delay, then activate it locally in seconds.

Connect Anything gateway

Create public webhook endpoints for Stripe, GitHub, Shopify or custom providers with signature checks, toggles and test deliveries.

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.

The local development lab

From public request to reproducible bug.

Routa is the layer between the internet and your local services: observe, control, branch, break and replay every interaction from one place.

Discover services

Scan local ports, identify HTTP services and confirm proposed routes before traffic is forwarded.

Map the API

Normalize dynamic paths and track volume, methods, latency, errors and body schemas as traffic arrives.

Create a mock

Turn any captured response into a local mock, then edit its status, JSON body and delay.

Connect anything

Generate public webhook endpoints for Stripe, GitHub, Shopify, Slack, Discord or custom providers.

Replay precisely

Re-fire a request exactly or edit its method, path, headers, query and JSON before sending.

Route many services

Send /auth, /api and /webhook traffic to different local ports from one public gateway.

Mutate traffic

Inject headers, rewrite paths, change query values, edit JSON dot-paths or return a forced response.

Break the network

Add latency and jitter, inject failures, drop connections or enforce upstream timeouts.

Shadow a rewrite

Duplicate traffic to a second implementation while the primary response still serves the client.

Diff responses

Compare status, timing, headers and nested JSON to see exactly what changed between implementations.

Save a session

Persist request history as a shareable fixture with ordering and inter-request timing intact.

Protect exposure

Use named tunnels, secrets, redaction rules, expiry and a kill switch before sharing localhost publicly.

Native everywhere

One Go binary. Six release targets.

Download a native executable for Apple Silicon, Intel Macs, Linux ARM servers, Raspberry Pi, Windows ARM laptops or standard x64 machines. Build the complete matrix from source with one command.

macOSApple Silicon / Intel

routa-darwin-arm64 · routa-darwin-amd64

LinuxARM servers / x86_64

routa-linux-arm64 · routa-linux-amd64

WindowsARM64 / AMD64

routa-windows-arm64.exe · routa-windows-amd64.exe

make build-all

CLI reference

The whole workflow stays scriptable.

routa dev 3000Inspect and forward a local service

routa dev 3000 --relay ws://relay.example.com:8080 --name my-appExpose a named public tunnel

routa dev --config routa.yamlLaunch reproducible routing and middleware

routa relay --port 8080 --domain relay.example.com:8080Run a self-hosted edge relay

routa versionPrint version and system information

Move the same routes, mutations, simulations, shadows and recording rules into a versioned routa.yaml file and run it with --config.

Why Routa

Not a free ngrok clone. A traffic control center.

Tunneling gets traffic to localhost. Routa gives you the inspection, discovery, mutation, failure testing, branching, diffing and deterministic playback that happen after the connection is made.

Capability	Routa	Ngrok	Postman	Mockoon
Tunneling	Routa +	Ngrok +	Postman -	Mockoon -
Live HTTP inspection	Routa +	Basic	-	-
API discovery & service mapping	Routa +	-	-	-
Traffic mutation & chaos	Routa +	-	-	Partial
Webhook gateway	Routa +	Basic	-	-
Replay, shadowing & deep diff	Routa +	-	Replay	-
Standalone Go binary	Routa +	Routa +	Heavy GUI	Separate tool

Quick start

Three steps to a public URL.

1
Install the binary
go install github.com/7uyash/routa/cmd/routa@latest
Go 1.21+, or grab a release build.
2
Run it against your port
routa dev 3000
Node, Go, Python, Rails — anything serving HTTP locally.
3
Open the dashboard
http://localhost:4040
Traffic starts streaming immediately.

Native release targets

macOS

ARM64 · AMD64

Linux

ARM64 · AMD64

Windows

ARM64 · AMD64

Download a native binary or build every target with make build-all.

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 repo Browse the docs

routaExpose localhost. Inspect everything. Replay anything.

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

One outbound connection carries everything.

Tunneling is the easy part. Control is the point.

Tunneling & relay

Live traffic inspector

Zero-config discovery

Automatic API mapping

1-click mock lab

Connect Anything gateway

Replay & edit-replay

Webhook lab

Multi-service routing

Failure simulator

Shadow traffic & deep diff

Sessions & playback

Guarded exposure

From public request to reproducible bug.

Discover services

Map the API

Create a mock

Connect anything

Replay precisely

Route many services

Mutate traffic

Break the network

Shadow a rewrite

Diff responses

Save a session

Protect exposure

One Go binary. Six release targets.

The whole workflow stays scriptable.

Not a free ngrok clone. A traffic control center.

Three steps to a public URL.

Reproduce the bug whenever you want.

Expose localhost. Inspect everything. Replay anything.