A local proxy manager — connect and route HTTP requests between your local servers from a single dashboard.
Watch the tour · Download · Features · Quick Start · Contributing
Modern local development rarely runs on a single server. Your frontend is on :3000, the API on :3001, an auth service on :4000 — and suddenly you're fighting CORS, cookies that won't cross ports, and webhooks that need one public URL.
Connectio puts all of them behind one local address. Define path rules like /api/* → localhost:3001 and /* → localhost:3000, hit Start, and every request is routed, logged, and inspectable — no nginx config to write, no reverse-proxy to restart. When you need to share it, flip on a temporary Cloudflare tunnel.
A 60-second tour of the happy path — add apps, route rules, start the server, inspect requests, share through a tunnel, and save configs as JSON.
Grab the latest build for your OS from the Releases page — .dmg for macOS (Apple Silicon), .exe for Windows, .AppImage or .deb for Linux.
Or install from the terminal:
# macOS / Linux
curl -fsSL https://raw.githubusercontent.com/PulkitBanta/connectio/main/scripts/install.sh | sh# Windows (PowerShell)
irm https://raw.githubusercontent.com/PulkitBanta/connectio/main/scripts/install.ps1 | iexNote
Connectio isn't code-signed yet, so macOS and Windows ask you to confirm the first time you open a downloaded build. See the installation guide for step-by-step instructions, plus updating and uninstalling.
- Proxy Apps — Create multiple proxy apps, each pointing to a different local server (e.g.
localhost:3001,localhost:4000). - Wildcard Route Rules — Define path-based routing rules with glob-style wildcards (
/api/*,/auth/login). Rules are matched in order, giving you full control over priority. - Detailed Request Logs — See every proxied request as it happens, then click a log to inspect its matched rule, target, connection metadata, and request/response headers.
- Temporary Cloudflare Tunnels — Opt in per config to expose the proxy at a temporary public
trycloudflare.comURL while the server is running. - App Ordering — Reorder proxy apps with up/down controls. Order determines rule priority — if the first app catches
/*, it takes precedence. - Config Manager — Browse, search, rename, and delete saved configurations from a dedicated configs list view.
- JSON Import / Export — Import configs by pasting raw JSON or selecting a file via the native dialog. Export any config as clipboard text or save as a
.jsonfile. - JSON Editor — Edit any config's raw JSON directly in-app with validation and save.
- Save & Load — Quickly save the current state to a named config or load a previously saved one from the sidebar panel.
- Collapsible Sidebar — Expand the left nav for full app names or collapse it to icon-only mode for more screen space.
- Cross-Platform — Runs on macOS, Windows, and Linux. Configs are stored in the OS-native user data directory.
More screenshots
 |
 |
| Home screen with server controls in the right sidebar | Reorder apps and route rules to control matching priority |
 |
 |
| Save and load named configurations | Browse, search, and manage saved configs |
 |
 |
Export a config to the clipboard or a .json file |
Import a config by pasting raw JSON |
Connectio runs an Express proxy server on a port you choose (default 8080). When a request comes in, it walks your route rules in order, finds the first match, and proxies the request to the target server using http-proxy-middleware. Each response is logged back to the UI in real time.
Browser / cURL Your local servers
│ ▲
│ GET /api/users │
▼ │
┌──────────┐ match: /api/* ┌─────────────────┐
│ Connectio│ ───────────────► │ localhost:3001 │
│ :8080 │ │ (API server) │
│ │ match: /* ├─────────────────┤
│ │ ───────────────► │ localhost:3000 │
└──────────┘ │ (Frontend) │
└─────────────────┘
- Click + in the left sidebar to add a proxy app.
- Give it a name (e.g. "API Server") and a target URL (e.g.
http://localhost:3001). - Click the app, then + Add Rule to define a route pattern like
/api/*. - Set your port in the right sidebar and hit Start Server.
- Send requests to
http://localhost:8080and watch them get routed and logged in real time. - Click any request in Recent Requests to inspect its matched rule, target, and headers.
Enable Cloudflare tunnel before starting the server. Connectio runs a Cloudflare Quick Tunnel, shows the generated public URL (click to copy), and closes it when you stop the server. This requires cloudflared on your PATH (or set CLOUDFLARED_PATH).
Warning
A tunnel makes every route in your proxy reachable by anyone on the internet who has the URL — there is no authentication in front of it. Only enable it for servers you're comfortable exposing, and stop the server when you're done. Quick Tunnels are intended for development and testing, not production.
Configs are saved as JSON files in the OS user data directory:
| OS | Path |
|---|---|
| macOS | ~/Library/Application Support/connectio/configs/ |
| Windows | %APPDATA%/connectio/configs/ |
| Linux | ~/.config/connectio/configs/ |
A config looks like this (cloudflareTunnel is optional and defaults to off):
{
"apps": [
{
"id": "api",
"name": "API Server",
"targetUrl": "http://localhost:3001",
"enabled": true,
"rules": [{ "id": "r1", "matchPath": "/api/*", "enabled": true }]
}
],
"port": 8080,
"cloudflareTunnel": false
}Contributions are welcome! Bug reports and feature ideas go in Issues; for code changes, open a pull request against main.
Requires Node.js v22+ and Yarn v1.
git clone https://github.com/PulkitBanta/connectio.git
cd connectio
yarn install
yarn dev # Start with DevTools open| Command | What it does |
|---|---|
yarn dev |
Start the app with hot reload and DevTools |
yarn start |
Preview the production build without DevTools |
yarn lint |
Run ESLint |
yarn format |
Run Prettier |
yarn build |
Build and package distributables into dist/ |
- Run
yarn lintandyarn formatbefore pushing. - Use Conventional Commits (
feat:,fix:,docs:,chore:, …) — release notes and version bumps are generated from them. - Keep PRs focused; include a screenshot for UI changes.
- Build — Every push to
mainand every PR runs the build workflow on macOS, Windows, and Linux. - Release — release-please watches
mainand keeps a release PR open with the next version and changelog. Merging that PR tags the release, and the release workflow builds all three platforms and attaches the installers to the GitHub Release.
Tech stack
- Desktop Shell — Electron with context isolation
- UI Framework — Solid.js with TypeScript — signals-based reactivity for fast, predictable renders
- Styling — Tailwind CSS v4 via
@tailwindcss/viteplugin - Icons — Lucide rendered as native Solid SVG components
- Build Tool — electron-vite — fast HMR for main, preload, and renderer
- Packaging — electron-builder — produces
.dmg,.AppImage,.deb,.exe - Proxy Server — Express 5 — incoming request handling
- Proxying — http-proxy-middleware — route matching and reverse proxying
- Linting — ESLint v10 with
typescript-eslint - Formatting — Prettier
Project structure
src/
├── main/ # Electron main process
│ ├── index.ts # App lifecycle, window creation
│ ├── server.ts # Proxy IPC handlers, request log + tunnel status forwarding
│ ├── configs.ts # Config CRUD — list, load, save, delete, rename, export, import
│ └── ipc.ts # Registers all IPC handlers
├── preload/
│ └── index.ts # Context bridge — exposes window.connectio to the renderer
├── renderer/ # Solid.js UI
│ ├── index.html # Shell HTML
│ ├── index.tsx # Solid entry point
│ ├── App.tsx # Root component — view router, layout
│ ├── components/ # UI components (Nav, ProxyView, ConfigsView, etc.)
│ ├── lib/ # State (signals), IPC client, utilities, constants
│ └── styles/
│ └── index.css # Tailwind entry
└── server.js # Express proxy server, rule matching, Cloudflare tunnel process
MIT © Pulkit Banta