Bowire
All Your Protocols. One UI. One Setup.
The multi-protocol API workbench for .NET with support for gRPC, REST, GraphQL, SignalR, WebSocket, SSE, MQTT, Socket.IO, OData, MCP, Storm, Kafka, DIS, UDP, and your custom protocol — all in a single tool.
No cloud restriction. No account required. Free and open source.
Built for API testing with even more swag than Swagger.
Ship Bowire: skip to the dock ↓
See it in action
Discovery, request, response, switch protocol — a full round-trip against the BowireDemo sample with gRPC, SignalR, REST, and WebSocket.
A single tool, every protocol — gRPC, REST, GraphQL, SignalR, MCP, SSE, WebSocket, MQTT, Socket.IO, OData, Storm, Kafka, DIS, UDP. No browser plugin, no separate desktop app, no protocol-specific UI quirks.
A single Bowire for every situation
Bowire understands your setup and shows the most useful tools and guidance depending on your task — from first-run welcome through single request and daily streaming workflows to recording and replays.
Connected & ready
Service summary, recent-history quick-recall, keyboard shortcut tips, guided tour entry point.
First-run welcome
Standalone tool without --url: two onboarding paths — connect to a live server, or upload a .proto / OpenAPI / GraphQL SDL.
Multi-URL discovery
Connect to multiple servers in parallel — per-URL status table with retry buttons for any that fail.
Smart error guidance
When discovery fails, the landing surfaces the actual error plus four common-cause troubleshoot bullets.
Work offline with a schema file
Drop in a .proto, OpenAPI spec, or GraphQL SDL and browse the API without a running server. Great for reviewing a contract during code review.
Visual flow editor
Chain API calls into branching pipelines — visual node editor with loops, conditions, and variable forwarding. No Postman Teams subscription required.
Streaming like Wireshark
Append-only message list + detail pane for server-streaming, client-streaming, and duplex. Filter by substring, jump to any frame, pin the latest.
Click any JSON value to chain
Hover a leaf or key in the response, click it, paste ${response.path.to.value} into the next request's body or URL.
Environment diff
Compare two environments side-by-side — spot drift before it hits production. Colour-coded equal / changed / only-in-A / only-in-B rows.
Command palette & vim keys
Press / anywhere to search methods, switch environments, filter protocols. Vim-style j/k navigation for power users.
Record & replay
Click record, run a sequence of calls, click stop. Replay against another environment, convert to test assertions, export as HAR or .blr.
Performance histogram
Repeat any call N times, watch the latency histogram + timeline render in real time. P50 / P90 / P99 percentiles, success rate, throughput.
Per-plugin settings
General, shortcuts, data management, and a dedicated section per installed protocol plugin — each protocol defines its own BowirePluginSetting schema.
Straight into the water
Three steps from slipway to running Bowire.
Which boat are you stepping into today?
Different rig: see every download →
Why Bowire?
What makes Bowire different from Postman, Insomnia, Scalar, and other API tools.
Protocols in One UI
- gRPC
- REST
- GraphQL
- SignalR
- WebSocket
- SSE
- MQTT
- Socket.IO
- OData
- MCP
- Storm
- Kafka
- DIS
- UDP
- Custom
Built for every protocol you need plus your own via Bowire's plugin API.
No schema files to maintain — each protocol auto-discovers through its native mechanism (Reflection, OpenAPI, introspection, …).
Bonus for Embedded Mode: Bowire wires the server-side prerequisites in for you.
Embedded — Zero Config
AddBowire() + MapBowire() in your Program.cs — that's it.
Bowire auto-discovers all registered services and wires the protocol prerequisites (gRPC Reflection, etc.) in for you. No schema files, no manual endpoint lists.
Embedded — zero config
AddBowire() + MapBowire() in Program.cs, and Bowire ships next to your service. No companion process, no extra container, no shared database.
The plugin host hooks into the same DI container your app already builds. Discovery, invocation, and recording all run in-process against the live IServiceProvider — the workbench is part of the service rather than a sidecar.
Protocol prerequisites that you'd normally wire by hand are added automatically: gRPC plugins call AddGrpcReflection(), REST plugins read the existing IApiDescriptionGroupCollectionProvider, SignalR plugins enumerate mapped hubs via EndpointDataSource. No schema files, no manual endpoint registry, no parallel proto / yaml to keep in sync.
100% Local — No Cloud
No accounts. No telemetry. No data leaves your machine. Everything persists in localStorage and ~/.bowire/.
Enterprise security teams love this — no third-party data processing agreements needed.
100% Local — no cloud
No accounts. No telemetry. No data leaves your machine. Bowire persists every credential, recording, and environment to your disk.
Workspace state lives in browser localStorage (per-origin, so dev/staging/prod each have their own). Recordings, plugins, and shared environments persist under ~/.bowire/ — a plain JSON tree on the file system that you can grep, diff, and check into a private repository if your team wants shared environments without paying for a sync service.
Outbound connections only happen when you tell Bowire to make one: clicking Execute hits the target API, that's it. No background pings, no opt-out telemetry, no remote feature flags. Enterprise security teams sign off in minutes — there's nothing to put in a Data Processing Agreement because there's no third party in the chain.
Open Plugin Architecture
Every protocol is a NuGet package implementing IBowireProtocol. Discovery, Invoke, Stream, Channel, Settings — one interface, infinite protocols.
Community plugins install via bowire plugin install.
Open plugin architecture
Every protocol is a NuGet package implementing IBowireProtocol. Discovery, Invoke, Stream, Channel, Settings — one interface, infinite protocols.
Plugins ship as ordinary NuGet packages. Bowire loads them into per-package AssemblyLoadContexts so a plugin's transitive dependencies don't collide with the host or with each other — you can install the gRPC plugin (which pins one Google.Protobuf version), the GraphQL plugin (which pins another), and a third-party protocol (which pins a third), and they all coexist.
End-users install via bowire plugin install <package-id>; air-gapped users via bowire plugin download + install --file. The same contract powers the official plugins (gRPC, REST, GraphQL, SignalR, …) and external ones (Storm, Kafka, DIS, UDP).
Duplex Channel Manager
WebSocket, SignalR, MQTT, Socket.IO — all bidirectional protocols get persistent channels with automatic stash/restore when switching between methods.
No other tool manages simultaneous duplex connections across protocols.
Duplex channel manager
WebSocket, SignalR, MQTT, Socket.IO — every bidirectional protocol gets a persistent channel. Switch between methods and Bowire stashes the live socket; come back and it's still connected.
Most API tools either drop the socket the moment you click off the method (Postman) or only support one connection per workspace at a time (Insomnia). Bowire tracks each open channel as its own object: connect to a SignalR hub on one tab, an MQTT broker on another, a raw WebSocket on a third, and all three keep streaming.
Per-channel state means request history, sent messages, and received frames all stay grouped per connection. The Wireshark-style append-only viewer shows every event with timestamps, so a long-running stream stays inspectable hours later.
Visual Flow Editor
Chain API calls into visual pipelines with branching conditions, loops, delays, and variable forwarding.
Color-coded node cards, drag-to-reorder, inline editing, response viewer per step — no Postman Teams subscription required.
Visual flow editor
Chain API calls into visual pipelines — branching conditions, loops, delays, variable forwarding. The kind of orchestration Postman locks behind a Teams subscription.
Each step is a node on a canvas: pick the service + method, set inputs (literal or ${response.path} from a previous step), choose what to do with the result. Branching nodes split on response value, status, or timing; loop nodes iterate over an array or repeat until a condition fires; delay nodes pause for a fixed interval or external trigger.
Run the flow once interactively and Bowire shows the response from every step inline. Pin it to an environment and run from CI via bowire test --flow — same orchestration, same output, no GUI needed.
Record and Replay
Capture a real session once, then serve the exact same responses as a live mock endpoint — same protocols, same payloads, same timing.
Unblock frontend work before the backend ships, run contract tests offline, or share a realistic sandbox with stakeholders without exposing production.
Record and replay
Capture a real session once. Serve the exact same responses back as a live mock endpoint — same protocols, same payloads, same timing.
Click Record, run a sequence of calls, click Stop: now you have a JSON file with every request, response, status, header, and inter-call timing across every protocol you touched — gRPC streams next to SignalR hub invocations next to MQTT publishes next to REST hits, all on one timeline.
Mocks aren't simulators, they're playback: every byte is what the real server actually sent. The mock server speaks every protocol the recording captured, so a test client sees exactly what production does — useful for unblocking frontend work before the backend ships, running offline contract tests, or sharing a realistic sandbox with a stakeholder without exposing the real environment.
Free and open source — and staying that way
Every feature on this page is in the free tier, because there is no other tier. Clone it, fork it, embed it in commercial products, audit the code, hack on it — no asterisks, no seat count, no "commercial use requires…".
Hull-to-hull: see the comparison table ↓
Built for modern APIs
Everything you need to discover, test, record, and debug your services across every protocol.
Discover & build
Auto-discovery with hot reload
Zero manual configuration. Drop in a protocol plugin and Bowire uses its native mechanism to enumerate services — then re-scans every few seconds so new endpoints show up without a refresh or restart.
Auto-discovery with hot reload
Plug in a protocol, get a service tree — no hand-maintained proto / OpenAPI / hub-registration code.
Each protocol plugin implements a single DiscoverAsync method: gRPC hits Server Reflection, REST reads the OpenAPI spec, SignalR enumerates mapped hubs via EndpointDataSource, GraphQL introspects __schema, MQTT subscribes to $SYS/#, and so on. Bowire merges the results into a single sidebar across every installed plugin.
The discovery pass repeats every few seconds against every configured URL. A new method registered on a running server shows up in the sidebar within the next tick — no page refresh, no re-upload, no "disconnect and retry" dance.
All call types
Unary, server streaming, client streaming, duplex channels, REST verbs, GraphQL queries / mutations / subscriptions, SignalR hub methods, raw WebSocket frames — every pattern in one UI.
Every call pattern in one UI
Unary, server-stream, client-stream, duplex — plus REST verbs, GraphQL subscriptions, SignalR hubs, raw WebSocket frames, MQTT publishes. One UI, same muscle memory across all of them.
Streaming calls render into a Wireshark-style append-only list with per-frame detail. Duplex / client-stream open a persistent channel with a "send next message" composer on one side and incoming frames on the other. REST maps verbs onto the same invoke pane; GraphQL has a selection-set picker plus subscription follow-up via graphql-transport-ws.
Form & JSON
Switch between auto-generated form fields (typed, validated, nested) and raw JSON editing per request. Schema-driven validation catches errors before they hit the wire.
Typed form or raw JSON — pick per call
Schema-driven form inputs for the common case, a full JSON editor when you need to tweak something unusual. Toggle with f.
The form view auto-generates controls from the discovered message shape: typed number inputs for int32, date pickers for google.protobuf.Timestamp, dropdowns for enums, nested cards for messages, repeated-field tables. Client-side validation flags missing required fields and type mismatches before a single byte hits the wire.
The JSON view is a full editor with syntax highlighting, bracket matching, and inline validation errors. State is preserved per method, so switching away and back never loses work.
Test & measure
Test assertions
Newman-style assertions that auto-run after every successful response. Eleven operators (eq, ne, gt, contains, matches, type, …). Pass / fail badges right in the response pane.
Inline test assertions
Write Newman-style checks once, Bowire runs them after every successful response and shows a green / red badge inline.
Eleven comparison operators (eq, ne, gt, gte, lt, lte, contains, startsWith, endsWith, matches, type) target any value via response.path.to.value JSONPath. Assertions are stored per method, replay with every invocation, and can be exported into a recording so a flow becomes its own regression test.
For streaming responses, assertions run on the accumulated frames — "expect at least 3 frames of type TICK within 2 s" is one rule. No plugins, no pipeline, just a test that lives next to the request.
Performance graphs
Repeat any call N times, watch the latency histogram + timeline render in real time. P50 / P90 / P99 / P99.9 percentiles, success rate, throughput. No external load tester needed.
Performance testing, built in
Repeat any call N times, watch the latency histogram and timeline render in real time.
P50 / P90 / P99 / P99.9 percentiles, success rate, and throughput all in the same pane as the request. No separate load tool to install, no CI pipeline to wire up — just a quick “is this endpoint holding up?” check when you suspect a regression. Scales enough for smoke tests; for full-blown soak tests, export the call as k6 / vegeta and run it from a proper load runner.
Recorder
Postman Collection-Runner parity. Click record, run a sequence of calls, click stop. Replay with current environment variables, convert into test assertions, or export as HAR for sharing.
Record & replay
Click record, run a sequence of calls, click stop. Now you have a reproducible test case, a debug artifact, and a future mock server in one file.
Recordings capture request, response, status, timing, and metadata for every call across every protocol — gRPC streams, SignalR hub invocations, WebSocket frames, MQTT publishes, REST hits, all in one timeline. Replay against another environment to check drift, convert into test assertions for CI, export as HAR for teammates, or (coming soon) serve the recording back as a live mock.
Connect & scale
Auth helpers
Bearer, Basic, API Key (header or query), JWT (HS / RS / ES), OAuth 2.0 client_credentials + authorization_code with PKCE, custom token endpoint with auto-refresh, AWS Signature v4 — per environment.
Every auth scheme, built in
Every auth scheme worth supporting, built in. Set it once per environment, Bowire signs every request.
Bearer tokens, HTTP Basic, API Key (header or query), JWT issuance (HS256 / RS256 / ES256) with custom claims, OAuth 2.0 client_credentials, OAuth 2.0 authorization_code with PKCE for local CLI flow, a custom token endpoint with auto-refresh, and AWS Signature v4 for S3 / Lambda / API Gateway. Each scheme stores its values in the environment, substituted at request time — tokens never touch the page source.
Expired tokens refresh transparently. Metadata headers on gRPC, authorization headers on REST / GraphQL / SignalR / WebSocket / MQTT (Username-Password CONNECT) all share the same credential store.
Environments & variables
Postman-style ${var} substitution in URLs, headers, and bodies. Switch between Dev / Staging / Prod, or connect to several servers in parallel — per-URL status indicators, per-service origin tagging.
Environments, variables, and drift diff
Postman-style ${var} substitution in URLs, headers, and bodies — plus a side-by-side diff so you see what changes between Dev and Prod before you call the wrong one.
Switch between Dev / Staging / Prod, or connect to several servers in parallel — per-URL status indicators, per-service origin tagging. Pick any two environments for a colour-coded diff: equal rows fold away, changed rows highlight, only-in-A / only-in-B clearly marked. Catches missing secrets, mistyped keys, and accidental overrides that would otherwise burn an afternoon of debugging.
CLI & standalone tool
bowire list, describe, call for scripting against any server. Or run as a global tool with the browser UI — every protocol plugin built in. No host code changes required.
CLI + standalone browser, same binary
Run as a .NET global tool and get three flavours of the same workbench — CLI subcommands for scripts, an HTTP-served UI for interactive use, and embedded middleware for teams that want the UI inside their own app.
bowire list <url> enumerates services, bowire describe <service.method> prints the full schema, bowire call <service.method> --body '{...}' invokes it — same output shape as the UI uses, so the CLI is scriptable against CI. Add --format json for machine-readable piping, or --recording to capture an output for later replay.
The standalone UI is just bowire --url https://api.example.com — the UI runs locally, hits the API with your auth, zero host-side changes. Plugin management (bowire plugin install / list / uninstall) shares the same state with the embedded mode.
Power tools
Vim-style keyboard navigation
j/k to hop methods, f to flip form/JSON, r to repeat, t to cycle themes, Ctrl+Enter to execute. Power users never touch the mouse.
Keyboard-first everything
Every action has a shortcut. Power users never touch the mouse; newcomers get a cheat sheet at ?.
Vim-style j / k to hop between methods in the sidebar, f to flip form ↔ JSON, r to repeat the last request, t to cycle light / dark / auto themes, Ctrl+Enter (or ⌘+Enter) to execute, Esc to close any modal, / to open the command palette, ? to see the full list without leaving the page.
Shortcuts are configurable per-user in Settings → Shortcuts, with conflict detection so the same chord never binds two actions silently.
Command palette
Press / anywhere to search methods, jump environments, apply protocol filters, or pin a name filter. Recently-used methods surface when the query is empty.
Command palette & keyboard flow
Press / anywhere to search methods, switch environments, filter protocols — never leave the keyboard.
Vim-style j / k to hop between methods, f to flip form / JSON, r to repeat the last request, t to cycle themes, Ctrl+Enter to execute. Recently-used methods surface when the palette query is empty. Power users who live in the shell will feel at home.
Click-to-chain responses
Hover any value in a response — click it and paste ${response.path.to.value} straight into the next request's body or URL. Works in JSON, tree, and streaming views.
Click any JSON value to chain
The response from one call is the input for the next. Bowire skips the copy-paste round-trip.
Hover any value or key in a rendered JSON response, click it, and Bowire places the chaining expression on your clipboard — ready to paste into the next request’s body, URL path, or headers. Works on every supported protocol, not just REST: gRPC response fields, GraphQL query results, SignalR hub return values, MQTT payloads, SSE events all use the same ${response.path.to.value} grammar.
Walk the deck: tour every feature →
Multi-protocol by design
One UI for every protocol your service stack speaks.
Each protocol is a plugin — install only what you need.
gRPC
Server Reflection, proto schema browser, all four streaming types (unary / server / client / duplex). Auto-generated request templates from protobuf definitions, plus HTTP transcoding for methods with google.api.http annotations.
$ dotnet add package Kuestenlogik.Bowire.Protocol.Grpc
gRPC
All four streaming flavours land in the same Wireshark-style frame pane — no separate tool for client-stream or duplex.
Bowire pulls the service tree from Server Reflection, generates typed request forms straight off the proto, and renders streaming responses frame-by-frame with per-message detail. HTTP transcoding kicks in automatically for methods carrying google.api.http, so REST-style hits work side by side with the gRPC call.
- Unary
- Server-streaming
- Client-streaming
- Bidi
- gRPC-Web
- Connect (planned)
REST
OpenAPI / Swagger document discovery with full path / query / header / body parameter forms. AWS Sig v4 signing built in. Drop in any swagger.json as a fallback when introspection isn't available.
$ dotnet add package Kuestenlogik.Bowire.Protocol.Rest
REST
REST that doesn't make you babysit a Postman collection — OpenAPI in, typed forms out, AWS Sig v4 already wired up.
Bowire pulls the schema from /swagger/v1/swagger.json (or any URL you point it at) and turns each operation into a typed form with separate path / query / header / body sections. Multipart uploads work out of the box, and streaming JSON / NDJSON responses render frame-by-frame in the same pane gRPC server-streaming uses.
- Request / response
- multipart upload
- streaming JSON / NDJSON
GraphQL
Schema introspection via __schema, visual selection-set picker for picking which fields you want returned, support for queries, mutations, and graphql-transport-ws subscriptions.
$ dotnet add package Kuestenlogik.Bowire.Protocol.GraphQL
GraphQL
A visual selection-set picker beats hand-rolling query strings — tick the fields you want, Bowire writes the query.
Bowire introspects __schema, lets you tick the fields you want returned, and renders nested object types as collapsible sub-trees. Subscriptions stream into the same Wireshark-style frame pane gRPC server-streaming uses, over either graphql-transport-ws or SSE.
- Query
- Mutation
- Subscription (over WS or SSE)
SignalR
Hub auto-discovery via endpoint metadata, method invocation with parameter type reflection, real-time bidirectional channels with the same UI as gRPC duplex streaming.
$ dotnet add package Kuestenlogik.Bowire.Protocol.SignalR
SignalR
Hubs show up in the sidebar without a hand-rolled JS test client — Bowire enumerates them straight from EndpointDataSource.
Auto-discovery walks the ASP.NET endpoint metadata to find every mapped hub, then reflects the method signatures so each gets a typed parameter form. Server-streaming and duplex hub channels render in the same Wireshark-style frame pane gRPC bidi uses.
- Invoke
- Server-streaming
- Duplex hub channels
MCP
AI agent integration for Claude Desktop, Cursor, and Copilot. Discovered methods are exposed as MCP tools with JSON Schema input. Bidirectional MCP server browser for inspecting tools published by other agents.
$ dotnet add package Kuestenlogik.Bowire.Protocol.Mcp
MCP
Bowire is an MCP client and server — inspect what Claude Desktop / Cursor / Copilot expose, or surface your own services as tools to them.
Each discovered Bowire method becomes an MCP tool with JSON Schema input, so any MCP-aware agent can call your services. The browser side connects over stdio today (with SSE and HTTP transports planned), enumerates remote tools, and lets you invoke them with the same typed-form UI used for everything else.
- Tool invocation (unary) over stdio
- SSE
- HTTP (planned)
SSE
Server-Sent Events — register endpoints via attribute or fluent API, watch live event streams render in the response pane. The same plugin powers GraphQL subscriptions and MCP server-push.
$ dotnet add package Kuestenlogik.Bowire.Protocol.Sse
SSE
One plugin, three jobs — raw SSE, GraphQL subscriptions, and MCP server-push all reuse the same streaming pipeline.
Register an endpoint via attribute or the fluent API, point Bowire at it, and live events render frame-by-frame in the same Wireshark-style pane gRPC server-streaming uses. Last-Event-ID resume and named event channels are honoured automatically.
- Server-streaming (one-way push)
WebSocket
Raw WebSocket frame editor with text + binary support, sub-protocol selection, per-frame type toggle. Open a channel, send a frame, watch responses arrive — same UI as the duplex gRPC and SignalR channels.
$ dotnet add package Kuestenlogik.Bowire.Protocol.WebSocket
WebSocket
Raw frame editor with the same duplex UI gRPC and SignalR get — no need for a separate browser tab full of wscat.
Send text or binary frames per side, flip frame type per message, negotiate a sub-protocol on connect. Incoming frames stream into the same Wireshark-style pane, with hex / UTF-8 toggle for binary payloads.
- Duplex text + binary frames
- sub-protocol negotiation
MQTT
Broker connect over TCP or WebSocket, topic subscribe with wildcards, retained-message inspection, QoS 0/1/2 publishes. Bidirectional channel reuses the same Wireshark-style stream pane as gRPC and SignalR.
$ dotnet add package Kuestenlogik.Bowire.Protocol.Mqtt
MQTT
Both 3.1.1 and 5.0 brokers in one client, with retained-message inspection and QoS 0/1/2 publishes from the same UI as every other call.
Connect over TCP or WebSocket, subscribe with wildcards (+, #), and watch live messages stream in the Wireshark-style frame pane. MQTT 5 request/response pairs (using correlation data + response topic) are correlated automatically and shown as a unified call.
- Pub / Sub
- Request / Response
- MQTT 3.1.1 + 5.0
Socket.IO
Namespace + room aware client, event emit / ack with JSON payloads, auto-reconnect with exponential backoff, binary event support. Works against any v2/v3/v4 Socket.IO server.
$ dotnet add package Kuestenlogik.Bowire.Protocol.SocketIO
Socket.IO
Namespace + room aware, with the ack callback wired into the same response pane — no JS console acrobatics.
Bowire picks the namespace, joins / leaves rooms on the fly, and emits typed events with JSON payloads. Acks come back as a normal response with timing; broadcast events stream into the duplex pane like any other channel. Works against v2 / v3 / v4 servers, with auto-reconnect on transport drop.
- Duplex with ack
- namespaces
- rooms
OData
CSDL metadata discovery, entity-set browser with typed filters ($filter, $orderby, $expand), batch requests, navigation-property follow-through. Works with ASP.NET's Microsoft.AspNetCore.OData.
$ dotnet add package Kuestenlogik.Bowire.Protocol.OData
OData
Build $filter / $expand / $select as picker UI — no more hand-encoding query strings to chase a bug.
Bowire reads CSDL metadata from /$metadata, renders entity sets in the sidebar, and gives each one a query builder for system query options. Bound functions and actions appear as their own callable methods. Works against ASP.NET's Microsoft.AspNetCore.OData stack and any V4-compliant service.
- Request / response
$filter/$expand/$select- functions / actions
Storm
Küstenlogik's Storm broker — native protocol via the KL.Storm.Client SDK or Kafka-compatible wire (?protocol=kafka). Topic browse, produce, server-streaming consume, in-process tap via storm://embedded.
$ bowire plugin install Kuestenlogik.Bowire.Protocol.Storm
Storm
First-class support for Küstenlogik's own broker — including the in-process storm://embedded tap that needs zero broker installed.
Connect with the native KL.Storm.Client SDK, or hit any Storm broker through its Kafka-compatible wire by appending ?protocol=kafka. Topic discovery, produce, partitioned consume, and consumer-group state are all visible in the same UI — the embedded mode is the fastest path from "is my pipeline producing?" to a green frame in the response pane.
- Topic produce (Unary)
- partitioned consume (Server-streaming)
- in-process tap
Kafka
Apache Kafka via Confluent.Kafka. Topic discovery via the Admin API, produce / consume with the standard JSON envelope, mTLS + SASL auth, plus optional ?schema-registry=… for live Avro decode of consumed messages.
$ bowire plugin install Kuestenlogik.Bowire.Protocol.Kafka
Kafka
Live Avro decode against Schema Registry — consumed records show up as JSON in the frame pane instead of opaque bytes.
Bowire connects with Confluent.Kafka, discovers topics via the Admin API, and uses the standard envelope so produce / consume work the same as every other protocol. Append ?schema-registry=https://... and Avro records are decoded inline; mTLS and SASL credentials live in the environment alongside every other auth scheme.
- Produce (Unary)
- Consume (Server-streaming)
- Schema Registry decode (Avro)
DIS
IEEE 1278 Distributed Interactive Simulation. UDP multicast listener for live PDU traffic, structured rendering of EntityState / Fire / Detonation / Collision PDUs, on-wire hex dump for binary inspection. Standalone-mode plugin for simulation environments.
$ bowire plugin install Kuestenlogik.Bowire.Protocol.Dis
DIS
Typed PDU rendering for IEEE 1278 traffic — EntityState / Fire / Detonation / Collision get a real form, not just a hex blob.
Subscribe to a multicast group, watch live PDUs land in the streaming pane with structured fields per type. Anything Bowire doesn't have a typed renderer for falls back to a canonical hex dump so binary inspection still works. Built for the same simulation environments as Storm and the Estuary stack.
- UDP-multicast PDU listen
- typed PDU rendering
- hex-dump fallback
UDP
Raw UDP datagram listener — feed any UDP source into the Bowire streaming pane. Auto-detects UTF-8 text payloads, falls back to base64 + canonical hex dump for binary. Sibling to the DIS plugin via the same IBowireMockEmitter contract.
$ bowire plugin install Kuestenlogik.Bowire.Protocol.Udp
UDP
A general-purpose UDP listener that feels like every other protocol — same streaming pane, same hex / UTF-8 toggle, same recording support.
Listen on multicast, broadcast, or unicast addresses; Bowire auto-detects UTF-8 payloads and falls back to base64 + canonical hex dump for raw binary. Shares the IBowireMockEmitter contract with the DIS plugin, so the same harness works for both.
- Datagram listen
- multicast / broadcast / unicast
- UTF-8 + hex
Akka.NET
Live tap on any Akka.NET ActorSystem — the BowireTapMailbox wraps the standard mailbox and streams every Tell into the workbench. Embedded mode only; opt in globally via the default-mailbox swap or per-actor with Props.WithMailbox.
$ bowire plugin install Kuestenlogik.Bowire.Protocol.Akka
Akka.NET
A passive mailbox tap means you can watch every Tell in your actor system without changing a line of business code.
The BowireTapMailbox wraps Akka.NET's standard mailbox and streams each message into the workbench in real time — per-actor or globally via the default-mailbox swap. Embedded mode only, since the tap runs in the same process as the ActorSystem; nothing leaves the host unless you choose to expose it.
- Mailbox tap (Server-streaming)
- embedded only
Coming soon
SOAP for enterprise legacy, NATS for cloud-native messaging, AMQP for RabbitMQ / ActiveMQ, Connect (Buf) over HTTP/1.1+JSON. More on the roadmap →
Planned pluginsYour Protocol
Implement IBowireProtocol to add support for any protocol. Bowire discovers plugins automatically via assembly scanning — drop a DLL into ~/.bowire/plugins/ and it's loaded at the next startup.
// implement IBowireProtocol in your own package
For another protocol: join the crew
Built for four kinds of workflows
Bowire isn't a Postman replacement — it's a workbench for the situations where Postman doesn't fit. Pick the workflow that sounds most like yours.
Backend developers
embedded mode · zero account walls
You're building an ASP.NET service and you want a debug UI inside your app for your team and your users — not a separate Electron app behind a sign-up flow. Add app.MapBowire(), ship the binary, every endpoint is browsable at /bowire.
→ gRPC reflection · OpenAPI · GraphQL introspection · SignalR endpoint scan
API integration testers
recorder · environments · assertions
You're verifying that an external API behaves the way the docs claim. Click Record, run a sequence of calls, click stop. Replay against Dev / Staging / Prod with environment-variable substitution. Convert the captured responses into regression assertions with one click.
→ Postman Collection-Runner parity · HAR export · Newman-style assertions
AI agent builders
MCP adapter · Claude / Cursor / Copilot
You're wiring an AI agent up to internal services. Bowire's MCP adapter exposes every discovered method as an MCP tool with JSON Schema input — without writing the MCP server boilerplate yourself. Drop the URL into your agent config and your assistant has typed access to your service surface.
→ --enable-mcp-adapter · auto-tool generation · streaming support
Documentation teams
interactive docs · live examples · code export
You're writing API docs and you want every example to be runnable without a curl-paste-and-pray loop. Embed Bowire next to your written guides — readers click a method, edit the JSON, hit Send, see the actual response. Export the call as curl, grpcurl, or a typed C# / TypeScript snippet.
→ Live examples · per-language code export · embedded in your own docs site
For another workflow: join the crew
Pick the right tool
Postman, Scalar, Swashbuckle, Insomnia, Bruno — every API tool has its sweet spot.
Here's where Bowire lands.
Shell tools (curl, HTTPie) aren’t listed — Bowire exports every call as a curl snippet when you need one.
Pick a tool above to see when it fits better than Bowire — and when Bowire is the right call.
Bowire vs. Postman
Pick Postman when a distributed team collaborates on curated API collections in the cloud, your stack is primarily REST / GraphQL / WebSocket, and features like Agent Mode, Public Workspaces, and seat-based sync are worth the account + subscription.
Pick Bowire when you need more protocols (gRPC streaming, SignalR, MCP, MQTT, Socket.IO, OData, …) in one workbench, want local-first (no Kong/Postman account, no cloud), or need the UI embedded in your ASP.NET service for ops teams.
Bowire vs. Scalar
Pick Scalar when your workflow is spec-first: an openapi.yaml / swagger.json is the source of truth, server + clients are generated from it, and you want a polished public docs site with a built-in Try-it console. Scalar reads the spec and renders it beautifully — great fit for contract-first REST APIs where the contract is designed before implementation.
Pick Bowire when the direction is reversed: a running server is the source of truth and Bowire discovers the contract at runtime (gRPC reflection, the OpenAPI document the server emits, SignalR hub enumeration, GraphQL introspection, …). Bowire lands one workbench across every protocol your service actually speaks — not only REST — and embeds directly inside the ASP.NET app instead of being a separate hosted site.
Bowire vs. Swashbuckle / Microsoft.AspNetCore.OpenApi
Pick Swashbuckle (or Microsoft’s new built-in OpenAPI in .NET 9+) when pre-built / offline generation and distribution of OpenAPI specs is enough for your workflow. Note that Swagger UI itself is legacy — Scalar or Bowire make a simple migration path, both consume the same OpenAPI document you already emit.
Pick Bowire when the same service exposes gRPC, SignalR, WebSocket, MCP, or other protocols alongside REST. Bowire reads the OpenAPI document you already generate and layers every other protocol on top — one workbench instead of five different tools.
Bowire vs. Insomnia
Pick Insomnia when you want a solid local-first desktop client for REST / GraphQL / gRPC / WebSocket, and you’re fine with Kong’s account layer for Sync, Teams, and the Dev Portal.
Pick Bowire when you also need SignalR, MCP, MQTT, Socket.IO, OData, or custom protocols, or when you want the workbench embedded in your ASP.NET service instead of running a separate desktop app. No Kong account required for anything.
Bowire vs. Bruno
Pick Bruno when Git-native collections are your priority — REST / GraphQL / basic gRPC with .bru files committed to your repo. No cloud, no account, just text files reviewed like code.
Pick Bowire when you need gRPC streaming, GraphQL subscriptions, SignalR hubs, MQTT topics, Socket.IO, or the workbench embedded in your ASP.NET service. (Bowire will ship Git-native workspace files too — see the roadmap.)
Bowire vs. gRPC UI / grpcurl
Pick gRPC UI or grpcurl when you only care about gRPC and want a lightweight, single-purpose tool with minimal setup.
Pick Bowire when the same service exposes REST or SignalR alongside gRPC and you don’t want to switch tools mid-session. Bowire also has a Wireshark-style append-only streaming view that beats the chat-style drawer for long duplex sessions.
Dig into the details
The positioning above is the quick read. The table below is the exhaustive check — useful when you're evaluating Bowire for a specific project.
- Full support
- Partial / limited (hover for details)
- Not supported
| Bowire | Postman | Scalar | Swashbuckle | Insomnia | Bruno | |
|---|---|---|---|---|---|---|
| 15+ | 7 | 1 | 1 | 5 | 4 | |
| gRPC | ✓ | ✓ | ✗ | ✗ | ✓ | partial |
| REST / HTTP | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| GraphQL | ✓ | ✓ | ✗ | ✗ | ✓ | partial |
| SignalR | ✓ | ✗ | ✗ | ✗ | ✗ | ✗ |
| MCP | ✓ | ✓ | ✗ | ✗ | ✗ | ✗ |
| SSE | ✓ | ✗ | ✗ | ✗ | ✓ | ✗ |
| WebSocket | ✓ | ✓ | ✗ | ✗ | ✓ | ✓ |
| MQTT | ✓ | ✓ | ✗ | ✗ | ✗ | ✗ |
| Socket.IO | ✓ | ✓ | ✗ | ✗ | ✗ | ✗ |
| OData | ✓ | ✗ | ✗ | ✗ | ✗ | ✗ |
| Storm | ✓ | ✗ | ✗ | ✗ | ✗ | ✗ |
| Kafka | ✓ | ✗ | ✗ | ✗ | ✗ | ✗ |
| DIS (IEEE 1278) | ✓ | ✗ | ✗ | ✗ | ✗ | ✗ |
| UDP (raw datagrams) | ✓ | ✗ | ✗ | ✗ | ✗ | ✗ |
| Akka.NET (mailbox tap) | ✓ | ✗ | ✗ | ✗ | ✗ | ✗ |
| Custom (plugin) | ✓ | ✗ | ✗ | ✗ | ✗ | ✗ |
| Custom protocol plugins | ✓ | ✗ | ✗ | ✗ | ✗ | ✗ |
| ✓ | manual | OpenAPI | OpenAPI | manual | manual | |
| gRPC Reflection | ✓ | ✓ | ✗ | ✗ | ✓ | ✓ |
| OpenAPI / Swagger import | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| GraphQL introspection | ✓ | ✓ | ✗ | ✗ | ✓ | ✓ |
| Proto file loading | ✓ | ✓ | ✗ | ✗ | ✓ | ✓ |
| Schema registry lookup | planned | ✗ | ✗ | ✗ | ✗ | ✗ |
| Embedded in ASP.NET app | ✓ | ✗ | ✓ | ✓ | ✗ | ✗ |
| Standalone tool | ✓ | ✓ | ✗ | ✗ | ✓ | ✓ |
| CLI mode | ✓ | ✓ | ✗ | ✗ | ✓ | ✓ |
| ✓ | Enterprise (paid) | ✓ | ✓ | Enterprise (paid) | ✓ | |
| Docker image | planned | ✓ | ✓ | ✓ | ✓ | ✓ |
| Compose manifest | planned | ✓ | ✓ | ✓ | ✓ | ✓ |
| Kubernetes / Helm | planned | ✓ | ✓ | ✓ | ✓ | manual |
| Air-gapped install | ✓ | Enterprise (paid) | ✓ | ✓ | Enterprise (paid) | ✓ |
| SSO / SCIM | ✗ | Enterprise (paid) | Enterprise (paid) | ✗ | Enterprise (paid) | ✗ |
| Native .NET (no Electron) | ✓ | ✗ | via Scalar.AspNetCore | ✓ | ✗ | ✗ |
| ✓ | Collections | ✗ | ✗ | partial | ✗ | |
| Record session | ✓ | ✓ | ✗ | ✗ | ✓ | ✗ |
| Replay against env | ✓ | ✓ | ✗ | ✗ | ✓ | ✗ |
| HAR export | ✓ | ✓ | ✗ | ✗ | ✓ | ✗ |
| Convert to test assertions | ✓ | ✓ | ✗ | ✗ | via Inso CLI | ✗ |
| Native export format | .blr | Collection JSON | ✗ | ✗ | Insomnia JSON | .bru |
| Replay as mock server | ✓ | paid cloud | ✗ | ✗ | self-host (Enterprise) | ✗ |
| Multiple duplex channels | ✓ | one at a time | ✗ | ✗ | one at a time | one at a time |
| ✓ | paid cloud | ✗ | ✗ | ✗ | ✗ | |
| Branching (if / else) | ✓ | paid cloud | ✗ | ✗ | ✗ | ✗ |
| Loops | ✓ | paid cloud | ✗ | ✗ | ✗ | ✗ |
| Delays / wait steps | ✓ | paid cloud | ✗ | ✗ | ✗ | ✗ |
| Variable forwarding | ✓ | paid cloud | ✗ | ✗ | ✗ | ✗ |
| Per-step assertions | ✓ | paid cloud | ✗ | ✗ | ✗ | ✗ |
| Performance / load testing | ✓ | k6 (separate) | ✗ | ✗ | ✗ | ✗ |
| Local-first, no account | ✓ | account required | cloud-hosted | ✓ | account required | ✓ |
| Git-native workspace | planned | ✗ | ✗ | ✗ | Git Sync (cloud) | ✓ |
| via Storm Registry | Public Workspaces | ✓ | Swagger UI | partial | ✗ | |
| Hosted docs page | ✗ | ✓ | ✓ | ✓ | Kong portal | ✗ |
| Custom domain | ✗ | Enterprise (paid) | Pro (paid) | ✓ | ✗ | ✗ |
| Try-It-Out widget | via client | ✓ | ✓ | ✓ | ✗ | ✗ |
| API versioning | via Storm Registry | ✓ | Pro (paid) | manual | ✗ | ✗ |
| Catalog / search | via Storm Registry | Public API Network | ✓ | ✗ | ✗ | ✗ |
| any protocol | full MCP server | REST docs only | ✗ | client only | ✗ | |
| Tools capability | ✓ | ✓ | ✗ | ✗ | ✗ | ✗ |
| Resources capability | planned | ✓ | docs-as-resources | ✗ | ✗ | ✗ |
| Prompts capability | planned | ✓ | ✗ | ✗ | ✗ | ✗ |
| stdio transport | ✓ | ✓ | ✗ | ✗ | client only | ✗ |
| SSE transport | planned | ✓ | ✗ | ✗ | ✗ | ✗ |
| HTTP transport | planned | ✓ | ✗ | ✗ | ✗ | ✗ |
| ✓ | ✓ | ✗ | ✗ | ✗ | ✗ | |
| Recording start / stop | ✓ | ✓ | ✗ | ✗ | ✗ | ✗ |
| Environment list | ✓ | ✓ | ✗ | ✗ | ✗ | ✗ |
| Replay execute | ✓ | ✓ | ✗ | ✗ | ✗ | ✗ |
| Mock spin-up | ✓ | ✓ | ✗ | ✗ | ✗ | ✗ |
| Collection / workspace mgmt | ✗ | ✓ | ✗ | ✗ | ✗ | ✗ |
| License | Apache 2.0 | Proprietary | MIT | MIT | Apache 2.0 (core only!) | MIT |
| Price | Free | Freemium | Freemium | Free | Freemium | Free |
Comparison reflects the public feature matrix as of 2026-04. Postman, Scalar, Swashbuckle, Insomnia and Bruno are excellent tools in their own niches — Bowire is designed for the .NET ecosystem and devs who want every protocol in one place, embeddable into their own service, with zero account walls.
Spotted something wrong? Tools move fast — if we’ve misrepresented a feature or missed one that has since shipped, please open an issue and we’ll update the matrix.
Below decks: tour every feature →
What’s next
A short look at what’s on the roadmap.
Replay recordings as a mock server
A bowire mock CLI that turns any captured recording into a live endpoint — same services, same payloads, same timing. Swap protocols on match, simulate latency, hot-reload on edit.
More protocols: SOAP, NATS, Akka.NET
SOAP for the enterprise legacy that still runs your invoicing, NATS for cloud-native messaging, Akka.NET actor inspection for distributed-system introspection. One UI, three very different wire protocols, zero context-switching.
Full MCP spec + AI-driven testing
Expose Bowire’s own discovery / invoke / record primitives as MCP tools so an agent can chain discover → invoke → assert → switch env → replay. Ship the full MCP spec — resources + prompts alongside tools, plus SSE / HTTP transport so remote clients like Cursor and Copilot can connect without stdio.
Sidecar packaging for non-.NET teams
First-class Docker / Compose / Kubernetes images so teams running Go, Rust, Python, or Node services can drop Bowire next to their API with a single manifest — no .NET toolchain on the host required.
Schema registry + proto / Hyperion decoding
Ship a message-type registry (Storm-compatible) that feeds the protocol plugins. Binary Proto payloads and Akka.NET Hyperion-serialized messages decode inline — no need to pre-load every .proto file or manually register types.
Doubles as a developer-to-developer schema distribution channel: publish your API’s schemas to the registry, and any Bowire instance can pull and explore them — the OSS alternative to Postman Public Workspaces or hosted Scalar docs, without a marketing portal.
Kafka / Storm topics
Browse topics as services, produce & consume messages with consumer-group awareness, decode payloads through the schema registry (Avro, Proto, Hyperion). One UI for request/response and event-stream surfaces in the same stack.
Nothing on this list is a commitment — Bowire is built in the open, and priorities shift with what users actually hit in practice. If something here matters to you, file an issue or start a discussion.
Chart the course: roadmap on GitHub →
Ship Bowire in 60 seconds
Four ways to run Bowire — from builtin to scripting. Pick what fits your workflow.
Add Bowire to your ASP.NET app. Auto-discovery for every protocol you install.
# Add Bowire core
dotnet add package Kuestenlogik.Bowire
# Add gRPC protocol (pick the ones you need)
dotnet add package Kuestenlogik.Bowire.Protocol.Grpcbuilder.Services.AddBowire(); // auto-configure installed protocols
// ... your app setup ...
app.MapBowire(); // mount UI + API at /bowireRun Bowire as a .NET tool. Opens the browser UI against any server — no code changes required.
# Install once
dotnet tool install -g Kuestenlogik.Bowire.Tool# Launch the UI in your browser
bowire --url https://myserverDrop the Bowire container next to your service in Docker Compose or Kubernetes. Zero code change, language-agnostic — works with any server using a supported protocol.
# Run alongside your existing service
services:
myapp:
image: myapp:latest
ports: ["443:443"]
bowire:
image: kuestenlogik/bowire:latest
command: ["--url", "http://myapp:443", "--no-browser"]
ports: ["5080:5080"]
depends_on: [myapp]# As a pod sidecar — same network namespace as the main app
spec:
containers:
- name: myapp
image: myapp:latest
- name: bowire
image: kuestenlogik/bowire:latest
args: ["--url", "http://localhost:443", "--no-browser"]
ports: [{ containerPort: 5080 }]Same tool, terminal mode. Scriptable list, describe, and call commands for CI and automation.
# Install once
dotnet tool install -g Kuestenlogik.Bowire.Tool# Treat your APIs like Unix commands
bowire list --url https://myserver
bowire describe --url https://myserver WeatherService
bowire call --url https://myserver WeatherService/GetCurrentWeather -d '{"city":"Berlin"}'Set sail: downloads →
Join the crew
Bowire is Apache 2.0 and developed publicly on GitHub. Issues, pull requests, and the roadmap live in one place — all visible, all welcome.
All hands on deck: every community channel →
No catch. No paid tier, no account wall, no telemetry. Every feature on this page is in the free tier, because there is no other tier. Fork it, audit it, embed it in commercial products.
Cast off: ship Bowire →
Set sail. Discover APIs.