Native performance
HTTP runs through Rust HTTP (`reqwest`) — fast requests and low overhead.
Speed, privacy, and flow — built with Tauri v2 + React.
Open-source native API IDE for REST & WebSocket testing.
Fishman is a local-first API client built with Tauri v2 and React. It feels like a focused IDE for APIs — resizable panels, multi-tab requests, environments, collections, WebSocket sessions, a built-in terminal, and a multi-language backend scanner that turns your Node.js, Go, or Rust source code into ready-to-hit endpoints.
Beta · v0.1.1
Download Fishman
Linux and Windows 64-bit builds are ready. Now with WebSocket support, Go & Rust scanners, and built-in terminal. Pick your platform below — macOS is coming soon.
Windows 64-bit only
Windows builds are 64-bit (x64) only. 32-bit is not supported.
macOS builds are not available yet — follow the repo for updates.
Read the docs →Why Fishman
Built for speed, privacy, and flow. Fishman is a lightweight REST client that feels like a focused IDE for APIs.
Privacy by design
Collections, environments, history, and settings live locally via SQLite. Export only when you choose.
Code-aware scanning
Point Fishman at your Node, Go, or Rust project and it discovers routes and generates API collections.
IDE-grade UX
VS Code-style layout, resizable panels, multi-tab requests, and keyboard-first shortcuts.
Import & export
Bring in Postman collections and export Fishman or Postman when you need to share.
Themes that stay out of your way
Dark, light, or follow system — plus variable-aware inputs with live scope hints.
Features
Everything you need to build, inspect, and test APIs — with local-first speed.
Native desktop app
Tauri v2 + Rust HTTP for a fast, focused experience.
Automatic API discovery
Scan your backend source code and generate collections from real routes.
Workspace management
Organize requests, environments, and collections with a clean IDE-style layout.
Backend scanner
AST-based scanning for Node.js, Go, and Rust — route mounts, routers, and handler bindings.
Import & export
Postman import plus export to Fishman or Postman formats.
Dark mode
Dark by default, with light/system options.
Collections
Nested folders with rename, duplicate, and delete.
API testing
Multi-tab requests, request history, and fast response views.
Environment variables
`{{variable}}` substitution across URLs, headers, params, and body.
Authentication
Bearer, Basic, API key, JWT, OAuth2 token, plus custom headers.
Response viewer
Pretty JSON tree, raw/headers view, and HTML preview when applicable.
Cross platform
Build once, run where you need — native desktop distribution via Tauri.
WebSocket testing
Real-time WebSocket sessions alongside REST collections — connect, send, and inspect messages.
Built-in terminal
Run commands without leaving the app — integrated terminal tab in the tools panel.
Documentation generation
Auto-generate HTML API docs from your collections with one click.
Share collections
Share via Git, embed, or export — collaborate without a cloud workspace.
Network inspector
Monitor requests in the tools panel network table for debugging and inspection.
Keyboard shortcuts & zoom
App-wide keyboard shortcuts, zoom controls, and fullscreen support for power users.
Fishman vs popular API clients
Looking for an open-source Postman alternative? Here’s an honest look at how Fishman compares with Insomnia, Bruno, Hoppscotch, Thunder Client, and Apidog — focused on privacy, locality, and developer flow.
| Capability | Fishman | Postman | Insomnia | Bruno | Hoppscotch | Thunder Client | Apidog |
|---|---|---|---|---|---|---|---|
| Open source | Yes | No | Partial | Yes | Yes | No | No |
| Local-first / privacy | Strong (SQLite, no cloud required) | Cloud-centric by default | Local + sync options | Git-friendly local files | Web + self-host | VS Code local | Cloud + desktop |
| Native desktop | Yes (Tauri) | Yes | Yes | Yes | Web-first | Editor extension | Yes |
| Backend code → collections | Yes (Node.js, Go, Rust scanner) | Manual / import | Manual / import | Manual / import | Manual / import | Manual | Design/import focused |
| Postman import/export | Yes | Native | Yes | Import paths vary | Yes | Limited | Yes |
| WebSocket support | Yes (beta) | Yes | Yes | No | Yes | No | Yes |
| Multi-language scanner | Node.js, Go, Rust | No | No | No | No | No | No |
| Built-in terminal | Yes | No | No | No | No | No | No |
| Documentation generation | Yes | Yes | No | No | No | No | Yes |
| Collection sharing | Git, Embed, Export | Cloud workspace | Cloud sync | Git files | Cloud teams | Export only | Cloud teams |
Fishman aims to be a lightweight native alternative to Postman and Insomnia with Bruno-like local-first values — plus a backend scanner that turns real routes into testable collections.
Protocols & workflows
Built for REST and WebSocket testing today, with room to grow into GraphQL, gRPC, OpenAPI / Swagger, and design-first API workflows.
REST
Core support for request building, environments, auth, collections, and fast response inspection — the daily REST workflow.
Available now
OpenAPI / Swagger
Import and design-first APIs fit Fishman’s scanner and collection model. Use specs alongside (or instead of) hand-built requests as docs and tooling mature.
Import / design-first — expanding
GraphQL
GraphQL querying and schema-aware workflows are on the product vision path for teams that outgrow REST-only clients.
On the roadmap
gRPC
gRPC support is planned for service-to-service testing without leaving the same IDE-style workspace.
On the roadmap
WebSocket
Real-time WebSocket sessions alongside your REST collections — connect, send messages, and inspect responses in the same workspace.
Available now (beta)
Design-first APIs
Start from contracts (OpenAPI / Swagger) or from code via the backend scanner — then iterate collections locally without a mandatory cloud.
Code-first scanner live
Roadmap
Fishman is early and moving fast. Here’s what’s landed, what’s in progress, and what’s next.
Completed
- API Collections
- Request Builder
- Environment Variables
- Project Scanner (Node.js, Go, Rust)
- Import/Export enhancements
- Git integration & workflow polish
- Workspace layout improvements
- Documentation generation
- WebSocket support (beta)
In Progress
- Collection sharing & collaboration
- Network inspector
- Built-in terminal polish
Future
- Python Scanner
- Java Scanner
- Live backend sync
- AI API assistant
- Plugin architecture
- GraphQL & gRPC support
Future Vision
Fishman is evolving from an API client into an intelligent API IDE.
What’s next
- Multi-language backend support (Go + Rust)
- Documentation generation
- WebSocket support
- Live backend synchronization
- Automatic route updates
- Auto-generated request schemas
- AI understanding of APIs
Plugin-based architecture
Import/export and scanning are designed to be plugin-based. Planned format hooks include Postman, OpenAPI/Swagger, Insomnia, HAR, and cURL. Go and Rust scanners are live — Python, Java, PHP, C#, and Ruby are next.
Config & data
Theme: system · Timeout: 30s · Ignore SSL: off · Environments: global + per-collection
Open Source
Fishman is early and moving fast. Contributions are welcome — and if a license file is added, this page can reflect it automatically.
License status
Private / unlicensed for now — treat as proprietary unless a license file is added.
Want to help? Open issues, propose improvements, and ship better API tooling.
Documentation Preview
Quick entry points into setup, scanning, collections, and the workflows you’ll use daily.
Getting Started
Install, run, and ship your first API workflow locally.
Backend Scanner
Scan backend code into routes, request bodies, and collections.
Collections
Organize requests with nested folders and fast replayable history.
CLI
Coming soon — until then, use the app workflow.
API Reference
Endpoints and request/response details.
Installation
Prerequisites and production build commands.
FAQ
Quick answers about Fishman as a Postman alternative, local-first privacy, and protocol support.
Is Fishman a Postman alternative?
Yes. Fishman is an open-source, local-first API IDE for REST testing — a privacy-first Postman alternative with native desktop feel and backend scanning into collections.
How is Fishman different from Insomnia, Bruno, or Hoppscotch?
Like Bruno, Fishman prefers local data over cloud lock-in. Like Insomnia and Hoppscotch, it’s built for everyday API requests. Fishman’s differentiator is scanning backend source to generate collections — not only manual request authoring.
Can I import Postman collections?
Yes. Fishman supports Postman import plus export to Fishman or Postman formats so you can move workflows without rewriting everything.
Does Fishman support OpenAPI / Swagger?
OpenAPI / Swagger and design-first APIs are part of Fishman’s direction. Today you can build collections from code via the backend scanner; broader spec import workflows continue to expand.
What about GraphQL, gRPC, and WebSocket?
REST is the primary workflow. WebSocket support is now available in beta — connect, send, and inspect messages alongside your REST collections. GraphQL and gRPC support are planned.
Is my data local? Does Fishman work offline?
Collections, environments, history, and settings live locally via SQLite. You can work offline — no cloud account is required to stay productive.
How does the Backend Scanner work?
Point Fishman at your backend project. AST-based scanning discovers routes and generates request bodies and collections so you can hit endpoints without hand-copying paths from code. Supports Node.js (Express, Fastify, Koa, Hapi, NestJS), Go (Gin, Echo, Chi, net/http), and Rust (Actix, Axum).
How does Fishman compare to Thunder Client or Apidog?
Thunder Client lives inside VS Code; Apidog leans into design/docs platforms. Fishman is a standalone native desktop API IDE focused on speed, privacy, and scanning code into testable collections.
Is Fishman related to Integrate.io?
No. Integrate.io is a data integration platform. Fishman is an API client / API IDE for exploring and testing HTTP APIs — closer to Postman, Insomnia, Bruno, and Hoppscotch.
What languages does the scanner support?
Node.js (Express, Fastify, Koa, Hapi, NestJS), Go (Gin, Echo, Chi, net/http), and Rust (Actix, Axum). Python, Java, and more are planned.
Does Fishman have a built-in terminal?
Yes. Fishman includes a terminal tab in the tools panel for running commands without leaving the app.
Where can I read the docs?
Full documentation lives at nkrider7.github.io/fishman-docs, covering installation, getting started, backend scanning, and collections.
Understand your APIs. Build faster with Fishman.
Local-first API testing
Open-source native API IDE that discovers routes, scans your backend, and generates ready-to-test collections in seconds — without forcing a cloud workspace.
Multi-Language Scanner
Node.js · Go · Rust
WebSocket Support
Real-time Testing (Beta)
Built-in Terminal
Run Commands In-App
Offline First
No Cloud Required
